![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pdc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / pdc|
Return to pdc.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / pdc |
1.1 root 1: /*++
2:
3: Copyright (c) 1992 Microsoft Corporation
4:
5: Module Name:
6:
7: pdc.c
8:
9: Abstract:
10:
11: This is the main source file for the Windows/NT PDC API demonstration
12: program. This program demonstrates how to use many of the advanced
13: operating system features provided by the Win32 API set on Windows/NT.
14:
15: This file and its corresponding header file, pdc.h, can be found
16: in the sample programs directory of the PDC CD-ROM.
17:
18: This program has a real purpose, although the implementation is
19: somewhat contrived in order to demonstrate the various operating
20: system features of Windows/NT.
21:
22: The features that this program demonstrate are:
23:
24: - Creating multiple threads, using critical sections
25: and semaphores for synchronization.
26:
27: - Thread termination.
28:
29: - Virtual memory, commitment vs reservation.
30:
31: - Structured exception handling, including finally
32: clauses and an exception filter procedure.
33:
34: - Enumeration of directory entries.
35:
36: - Mapped file I/O
37:
38: - Asynchronous file I/O via completion routine.
39:
40: - Synchronous file I/O
41:
42: PDC is a character mode program for searching the files in a
43: directory tree for a match against a pattern. It uses multiple
44: threads to do it's work, with each thread processing a file at a
45: time, accumulating it's matches and outputting them to standard
46: output contiguously when it is done searching a file.
47:
48: The command line syntax is:
49:
50: Usage: PDC [-h] [-v] [-y] [-a | -s | -m] [-t n] SearchString [DirectoryPath]
51:
52: where:
53:
54: -h - prints this message.
55:
56: -v - generates verbose output.
57:
58: -y - ignores case when doing comparisons.
59:
60: -a - specifies that the program should use asynchronous file
61: I/O to read the files being searched.
62:
63: -s - specifies that the program should use synchronous file
64: I/O to read the files being searched.
65:
66: -m - specifies that the program should use mapped file I/O
67: to read the files being searched.
68:
69: -t - specifies the number of threads to use when doing the
70: search. Default is 4 * the number of processors.
71:
72: SearchString - specifies the text to search for. Enclose in
73: quotes if it contains spaces or punctuation.
74:
75: DirectoryPath - specifies the root of the tree to begin the
76: search at. Defaults to the current directory.
77:
78:
79: --*/
80:
81: #include "pdc.h"
82:
83:
84: int
85: main(
86: int argc,
87: char *argv[]
88: )
89:
90: /*++
91:
92: Routine Description:
93:
94: This is the main procedure for the PDC program, and is called by
95: the C Runtime startup code when the program starts.
96:
97: Arguments:
98:
99: argc - number of argumments in the argv array.
100:
101: argv - pointer to an array of null terminated string pointers.
102:
103: Return Value:
104:
105: Process exit status. The value returned by this function will
106: be used as the exit code parameter passed to ExitProcess.
107:
108: --*/
109:
110: {
111: SYSTEM_INFO SystemInformation;
112:
113: //
114: // Query the number of processors from the system and
115: // default the number of worker threads to 4 times that.
116: //
117:
118: GetSystemInfo( &SystemInformation );
119: NumberOfWorkerThreads = SystemInformation.dwNumberOfProcessors * 4;
120:
121: //
122: // Process the arguments given on the command line.
123: //
124:
125: if (!ProcessCommandLineArguments( argc, argv )) {
126: exit( 1 );
127: }
128:
129: //
130: // Allocate a thread local storage slot for use by our worker
131: // thread routine (ProcessRequest). This call reserves a
132: // 32-bit slot in the thread local storage array for every
133: // thread in this process. Remember the slot index in a global
134: // variable for use by our worker thread routine.
135: //
136:
137: TlsIndex = TlsAlloc();
138: if (TlsIndex == 0xFFFFFFFF) {
139: fprintf( stderr, "PDC: Unable to allocated thread local storage.\n" );
140: exit( 1 );
141: }
142:
143:
144: //
145: // Create a work queue, which will create the specified number of threads
146: // to process.
147: //
148:
149: WorkQueue = CreateWorkQueue( NumberOfWorkerThreads, ProcessRequest );
150: if (WorkQueue == NULL) {
151: fprintf( stderr, "PDC: Unable to create %u worker threads.\n", NumberOfWorkerThreads );
152: exit( 1 );
153: }
154:
155: //
156: // If using asynchronous I/O, create an event that will be signalled
157: // when there are no more outstanding I/O requests. The event is
158: // a manual reset event, that once signalled via SetEvent, will
159: // remain signalled until ResetEvent is called.
160: //
161:
162: if (ASyncIO) {
163: IoCompletedEvent = CreateEvent( NULL, // Not inherited
164: TRUE, // Manual reset
165: FALSE, // Initially reset
166: NULL // No name
167: );
168: }
169:
170: //
171: // Now walk the directory tree, which will call our procedure
172: // (QueueSearchFile) for each directory and file in the tree.
173: //
174:
175: EnumerateDirectoryTree( DirectoryPath,
176: QueueSearchFile,
177: NULL
178: );
179:
180: //
181: // Done walking the tree. If using asynchronous I/O, wait for all of
182: // the outstanding I/O requests to be completed.
183: //
184:
185: if (ASyncIO) {
186: //
187: // We use an alertable wait in a loop, as I/O completion
188: // will terminate the wait, even through the event we
189: // are waiting on is not signalled.
190: //
191:
192: while (WaitForSingleObjectEx( IoCompletedEvent,
193: 0xFFFFFFFF,
194: TRUE
195: ) == WAIT_IO_COMPLETION
196: ) {
197: ;
198: }
199: }
200:
201: //
202: // All done, destroy the work queue. This will wait for the work queues
203: // to empty before terminating the worker threads and destroying the
204: // queue.
205: //
206:
207: DestroyWorkQueue( WorkQueue );
208:
209: if (Verbose && MatchedLineCount) {
210: fprintf( stderr,
211: "Found %u lines with matches in %u files, out of %u files searched.\n",
212: MatchedLineCount,
213: MatchedFileCount,
214: SearchedFileCount
215: );
216: }
217:
218: return 0;
219: }
220:
221:
222:
223: VOID
224: QueueSearchFile(
225: LPSTR Path,
226: PWIN32_FIND_DATA FindFileData,
227: PVOID EnumerateParameter
228: )
229:
230: /*++
231:
232: Routine Description:
233:
234: This is the directory enumeration function. It is called by the
235: EnumerateDirectoryTree function once for each file and directory
236: in the tree.
237:
238: This function, if it decides it wants to search the file, will
239: open the file and then, depending upon the I/O method selected via
240: the command line, will:
241:
242: - map the file PAGE_READONLY for mapped file I/O
243:
244: - read the file into an allocated buffer for synchronous
245: I/O.
246:
247: - will allocate the buffer and start a read operation
248: to read the entire file into the buffer. A completion
249: routine will be invoked when the read completes, possibly
250: in another thread context.
251:
252: Finally it will queue a search request to the work queue, with the
253: relevant information contained in the request. For asynchronous
254: I/O, the search request is allocated and initialized here but is
255: not actually queued to the work queue until the I/O completion
256: routine has been called.
257:
258: Arguments:
259:
260: Path - Supplies a pointer to a null terminated string that contains
261: the fully qualified path of the file or directory.
262:
263: FindFileData - Supplies the directory information associated
264: with the file or directory specified by the Path argument.
265:
266: EnumerateParameter - Uninterpreted 32-bit value. Not used.
267:
268: Return Value:
269:
270: None.
271:
272: --*/
273:
274: {
275: PSEARCH_REQUEST SearchRequest;
276: HANDLE File;
277: HANDLE Mapping;
278: LPVOID FileData;
279: DWORD FileSize;
280:
281: //
282: // Ignore directories or zero length files, as there
283: // is nothing to search in these cases.
284: //
285:
286: if (FindFileData->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ||
287: !(FileSize = FindFileData->nFileSizeLow)
288: ) {
289: return;
290: }
291:
292: //
293: // Open the file using the fully qualified path. Specify the
294: // sequential scan hint to the cache manager and if asynchronous
295: // I/O will be used, specified the overlapped flag as well.
296: //
297:
298: File = CreateFile( Path,
299: GENERIC_READ,
300: FILE_SHARE_READ,
301: NULL,
302: OPEN_EXISTING,
303: FILE_FLAG_SEQUENTIAL_SCAN |
304: (ASyncIO ? FILE_FLAG_OVERLAPPED : 0),
305: NULL
306: );
307:
308: //
309: // Since NULL might be a valid file object handle, failure
310: // is indicated by a special return value.
311: //
312:
313: if (File == INVALID_HANDLE_VALUE) {
314: fprintf( stderr, "%s(0) : error %u: Unable to open file.\n",
315: Path,
316: GetLastError()
317: );
318:
319: return;
320: }
321:
322: //
323: // File successfully opened for read access.
324: //
325: if (MappedFileIO) {
326: //
327: // If mapped file I/O, create a file mapping object, backed by
328: // the file we just opened. Make the default page protection
329: // for the mapping be readonly.
330: //
331:
332: Mapping = CreateFileMapping( File,
333: NULL,
334: PAGE_READONLY,
335: 0,
336: 0,
337: NULL
338: );
339:
340: //
341: // Okay to close the file handle now, since the mapping object
342: // has a reference to the file that will cause the open file
343: // object to remain until the reference is destroyed. Note that
344: // any sharing information is lost at this point, so somebody
345: // could come in an open it for write access.
346: //
347:
348: CloseHandle( File );
349:
350: //
351: // Here, a null value indicates an error.
352: //
353:
354: if (Mapping == NULL) {
355: fprintf( stderr, "%s(0) : error %u: Unable to create mapping object.\n",
356: Path,
357: GetLastError()
358: );
359: return;
360: }
361:
362: //
363: // Finally, map a view of the file, using the mapping object
364: // just created, into the address space of this process.
365: // The offset and size are zero, which means to map the
366: // entire file.
367: //
368:
369: FileData = MapViewOfFile( Mapping,
370: FILE_MAP_READ,
371: 0,
372: 0,
373: 0
374: );
375:
376: //
377: // Okay to close the mapping object handle now, it will remained
378: // referenced as long as the view remains mapped.
379: //
380:
381: CloseHandle( Mapping );
382:
383: //
384: // A null value indicates the map operation failed.
385: //
386:
387: if (FileData == NULL) {
388: fprintf( stderr, "%s(0) : error %u: Unable to map file.\n",
389: Path,
390: GetLastError()
391: );
392: return;
393: }
394:
395: //
396: // All done mapping the file. Set the File handle to NULL as
397: // it has been closed already. Both the file object and mapping
398: // objects created above will be freed when the map view is
399: // unmapped.
400: //
401:
402: File = NULL;
403: }
404: else {
405: //
406: // Not using mapped I/O, so allocate a buffer big enough to
407: // contain the entire file.
408: //
409:
410: FileData = VirtualAlloc( NULL,
411: FileSize,
412: MEM_COMMIT,
413: PAGE_READWRITE
414: );
415: if (FileData == NULL) {
416: fprintf( stderr, "%s(0) : error %u: Unable to allocate memory to contain file.\n",
417: Path,
418: GetLastError()
419: );
420: CloseHandle( File );
421: return;
422: }
423: }
424:
425: //
426: // We have successfully opened the file and are ready to go.
427: // Allocate space for a search request and fill it in
428: // with the information needed by the ProcessSearchFile
429: // function when it runs.
430: //
431:
432: SearchRequest = LocalAlloc( LMEM_ZEROINIT,
433: sizeof( *SearchRequest ) +
434: strlen( Path ) + 1
435: );
436: if (SearchRequest == NULL) {
437: fprintf( stderr, "PDC: Out of memory\n" );
438: exit( 1 );
439: }
440:
441: SearchRequest->WorkItem.Reason = WORK_ITEM;
442: SearchRequest->File = File;
443: SearchRequest->FileSize = FileSize;
444: SearchRequest->FileData = FileData;
445: strcpy( SearchRequest->FullPathName, Path );
446:
447: if (!ASyncIO) {
448: //
449: // If not using asynchronous I/O, then queue the search
450: // request to the work queue.
451: //
452:
453: QueueWorkItem( WorkQueue, &SearchRequest->WorkItem );
454: }
455: else {
456: //
457: // Using asynchronous I/O, so queue the read operation.
458: // The file handle must remain open while the read operation
459: // is pending.
460: //
461:
462: if (!ReadFileEx( File,
463: FileData,
464: FileSize,
465: &SearchRequest->OverlappedIO,
466: ProcessReadFileCompletion
467: )
468: ) {
469: fprintf( stderr, "%s(0) : error %u: Unable to queue read of file.\n",
470: Path,
471: GetLastError()
472: );
473:
474: VirtualFree( FileData, 0, MEM_RELEASE );
475: CloseHandle( File );
476: LocalFree( SearchRequest );
477: return;
478: }
479:
480:
481: //
482: // Successfully queued the read operation. Keep a count
483: // of outstanding read operations so we know when it is
484: // okay to terminate.
485: //
486:
487: OutstandingIOOperations += 1;
488: }
489:
490: //
491: // Return back to the EnumerateDirectoryTree function so that it
492: // can call us with the next file or directrry.
493: //
494:
495: return;
496: }
497:
498:
499:
500: VOID
501: ProcessRequest(
502: IN PWORK_QUEUE_ITEM WorkItem
503: )
504:
505: /*++
506:
507: Routine Description:
508:
509: This function is called whenever a work item is removed from
510: the work queue by one of the worker threads. Which worker
511: thread context this function is called in is arbitrary.
512:
513: This functions keeps a pointer to state information in
514: thread local storage.
515:
516: This function is called once at the beginning with a
517: special initialization call. During this call, this
518: function allocates space for state information and
519: remembers the pointer to the state information in
520: a Thread Local Storage (TLS) slot.
521:
522: This function is called once at the end with a special
523: termination call. During this call, this function
524: frees the state information allocated during the
525: initialization call.
526:
527: In between these two calls are zero or more calls to
528: handle a work item. The work item is a search request
529: which is handled by the ProcessSearchFile function.
530:
531: Arguments:
532:
533: WorkItem - Supplies a pointer to the work item just removed
534: from the work queue. It is the responsibility of this
535: routine to free the memory used to hold the work item.
536:
537: Return Value:
538:
539: None.
540:
541: --*/
542:
543: {
544: DWORD BytesWritten;
545: PSEARCH_REQUEST_STATE State;
546: PSEARCH_REQUEST SearchRequest;
547:
548: if (WorkItem->Reason == WORK_INITIALIZE_ITEM) {
549: //
550: // First time initialization call. Allocate space for
551: // state information.
552: //
553:
554: State = LocalAlloc( LMEM_ZEROINIT,
555: sizeof( *State )
556: );
557:
558: if (State != NULL) {
559: //
560: // Now create a virtual buffer, with an initial commitment
561: // of zero and a maximum commitment of 128KB. This buffer
562: // will be used to accumulate the matched strings output
563: // during the search of a single file. This is so the
564: // output can be written to standard output with a single
565: // write call, thus insuring that it remains contiguous
566: // in the output stream, and is not intermingled with the
567: // output of the other worker threads.
568: //
569:
570: if (CreateVirtualBuffer( &State->Buffer, 0, 2 * 64 * 1024 )) {
571: //
572: // The CurrentOutput field of the state block is
573: // a pointer to where the next output goes in the
574: // buffer. It is initialized here and reset each
575: // time the buffer is flushed to standard output.
576: //
577:
578: State->CurrentOutput = State->Buffer.Base;
579: }
580: else {
581: LocalFree( State );
582: State = NULL;
583: }
584: }
585:
586: //
587: // Remember the pointer to the state informaiton
588: // thread local storage.
589: //
590:
591: TlsSetValue( TlsIndex, State );
592: return;
593: }
594:
595: //
596: // Here to handle a work item or special terminate call.
597: // Get the state pointer from thread local storage.
598: //
599:
600: State = (PSEARCH_REQUEST_STATE)TlsGetValue( TlsIndex );
601: if (State == NULL) {
602: return;
603: }
604:
605: //
606: // If this is the special terminate work item, free the virtual
607: // buffer and state block allocated above and set the thread
608: // local storage value to NULL. Return to caller.
609: //
610:
611: if (WorkItem->Reason == WORK_TERMINATE_ITEM) {
612: FreeVirtualBuffer( &State->Buffer );
613: LocalFree( State );
614: TlsSetValue( TlsIndex, NULL );
615: return;
616: }
617:
618: //
619: // If not an initialize or terminate work item, then must be a
620: // search request. Calculate the address of the search request
621: // block, based on the position of the WorkItem field in the
622: // SEARCH_REQUEST structure.
623: //
624:
625: SearchRequest = CONTAINING_RECORD( WorkItem, SEARCH_REQUEST, WorkItem );
626:
627: //
628: // Actual search operation is protected by a try ... except
629: // block so that any attempts to store into the virtual buffer
630: // will be handled correctly by extending the virtual buffer.
631: //
632:
633: try {
634: //
635: // Perform the search against this file.
636: //
637:
638: ProcessSearchFile( SearchRequest, State );
639:
640: //
641: // Done with this file. If using asynchronous I/O, decrement the
642: // count of outstanding I/O operations and it if goes to zero,
643: // then signal the IoCompletedEvent as there are no more outstanding
644: // I/O operations.
645: //
646:
647: if (ASyncIO && InterlockedDecrement( &OutstandingIOOperations ) == 0) {
648: SetEvent( IoCompletedEvent );
649: }
650:
651: //
652: // Free the storage used by the SearchRequest
653: //
654:
655: LocalFree( SearchRequest );
656:
657: //
658: // If any output was written to the virtual buffer,
659: // flush the output to standard output. Trim the
660: // virtual buffer back to zero committed pages.
661: //
662:
663: if (State->CurrentOutput > (LPSTR)State->Buffer.Base) {
664: WriteFile( GetStdHandle( STD_OUTPUT_HANDLE ),
665: State->Buffer.Base,
666: State->CurrentOutput - (LPSTR)State->Buffer.Base,
667: &BytesWritten,
668: NULL
669: );
670:
671: TrimVirtualBuffer( &State->Buffer );
672: State->CurrentOutput = (LPSTR)State->Buffer.Base;
673: }
674: }
675:
676: except( VirtualBufferExceptionFilter( GetExceptionCode(),
677: GetExceptionInformation(),
678: &State->Buffer
679: )
680: ) {
681:
682: //
683: // We will get here if the exception filter was unable to
684: // commit the memory.
685: //
686:
687: fprintf( stderr, "PDC: out of memory.\n" );
688: }
689:
690: //
691: // All done with this request. Return to the worker thread that
692: // called us.
693: //
694:
695: return;
696: }
697:
698:
699:
700: VOID
701: ProcessReadFileCompletion(
702: DWORD dwErrorCode,
703: DWORD dwNumberOfBytesTransfered,
704: LPOVERLAPPED lpOverlapped
705: )
706:
707: /*++
708:
709: Routine Description:
710:
711: This function is called whenever an asynchronous I/O operation,
712: queued by the previous function, completes. This function
713: calulates the address of the search request block and then
714: queue the request to the work queue, now that the data is
715: in memory.
716:
717: Arguments:
718:
719: dwErrorCode - Supplies the error code that the I/O completed with.
720:
721: dwNumberOfBytesTransfered - Supplies the actual number of bytes
722: transferred.
723:
724: lpOverlapped - Supplies a pointer to the structure given to
725: ReadFileEx when the I/O operation was queued.
726:
727: Return Value:
728:
729: None.
730:
731: --*/
732:
733: {
734: PSEARCH_REQUEST SearchRequest;
735:
736: //
737: // Since the data we need is now in memory, queue the search
738: // request to the work queue.
739: //
740:
741: SearchRequest = CONTAINING_RECORD( lpOverlapped, SEARCH_REQUEST, OverlappedIO );
742: QueueWorkItem( WorkQueue, &SearchRequest->WorkItem );
743: }
744:
745:
746:
747: VOID
748: ProcessSearchFile(
749: IN PSEARCH_REQUEST SearchRequest,
750: IN PSEARCH_REQUEST_STATE State
751: )
752:
753: /*++
754:
755: Routine Description:
756:
757: This function performs the actual search of the contents of the
758: passed file for the search string given on the command line.
759: If we are using synchronous I/O, then do the read operation
760: now.
761:
762: Search the contents of the file for any matches, and accumulate
763: the match output in the virtual buffer using sprintf, which is
764: multi-thread safe, even with the single threaded version of
765: the libraries.
766:
767: Arguments:
768:
769: SearchRequest - Supplies a pointer to the search request which
770: contains the relevant information.
771:
772: State - Supplies a pointer to state information for the current
773: thread.
774:
775: Return Value:
776:
777: None.
778:
779: --*/
780:
781: {
782: LPSTR FileData, s, s1, BegLine, EndLine, EndOfFile;
783: DWORD LineNumber;
784: DWORD MatchesFound;
785: DWORD BytesRead;
786:
787: //
788: // Get a pointer to the beginning of the file data in memory
789: // and calculate the address of the end of file point in
790: // memory.
791: //
792:
793: FileData = SearchRequest->FileData;
794: EndOfFile = FileData + SearchRequest->FileSize;
795:
796: //
797: // If using synchronous I/O, then we have not read in the
798: // file contents yet, so issue the synchronous read to get
799: // the data into memory.
800: //
801:
802: if (SyncIO) {
803: if (!ReadFile( SearchRequest->File,
804: FileData,
805: SearchRequest->FileSize,
806: &BytesRead,
807: NULL
808: ) ||
809: BytesRead != SearchRequest->FileSize
810: ) {
811: State->CurrentOutput += sprintf( State->CurrentOutput,
812: "%s(0) : error %u: Unable to read file contents.\n",
813: SearchRequest->FullPathName,
814: GetLastError()
815: );
816:
817: CloseHandle( SearchRequest->File );
818: return;
819: }
820: }
821:
822: //
823: // Close any open file handle associated with this request.
824: //
825:
826: if (SearchRequest->File != NULL) {
827: CloseHandle( SearchRequest->File );
828: }
829:
830: //
831: // Search the file contents, keeping track of line breaks
832: // so we can tell the line number of each match.
833: //
834:
835: s = FileData;
836: LineNumber = 0;
837: MatchesFound = 0;
838: while (s < EndOfFile) {
839: BegLine = s;
840: while (s < EndOfFile && *s != '\n') {
841: s++;
842: }
843:
844: if (*s == '\n') {
845: LineNumber += 1;
846: EndLine = s - 1;
847: if (EndLine > BegLine && EndLine[ -1 ] == '\r') {
848: EndLine -= 1;
849: }
850:
851: s1 = BegLine;
852: while (s1 < (EndLine - SearchStringLength)) {
853: if (!(SearchFunction)( s1, SearchString, SearchStringLength )) {
854: //
855: // We have a match for this line. Append the
856: // output to the virtual buffer and update the
857: // current output pointer.
858: //
859:
860: State->CurrentOutput += sprintf( State->CurrentOutput,
861: "%s(%u) : %.*s\n",
862: SearchRequest->FullPathName,
863: LineNumber,
864: EndLine - BegLine,
865: BegLine
866: );
867: MatchesFound += 1;
868: break;
869: }
870:
871: s1++;
872: }
873:
874: s++;
875: }
876: }
877:
878: if (MatchesFound) {
879: MatchedLineCount += MatchesFound;
880: MatchedFileCount += 1;
881: }
882: SearchedFileCount += 1;
883:
884: //
885: // All done with the file contents. Discard it either by
886: // unmapping the view of the file in the case of mapped file
887: // I/O or free the virtual memory for other types of I/O
888: //
889:
890: if (MappedFileIO) {
891: UnmapViewOfFile( FileData );
892: }
893: else {
894: VirtualFree( FileData, 0, MEM_RELEASE );
895: }
896: }
897:
898:
899: PWORK_QUEUE
900: CreateWorkQueue(
901: IN DWORD NumberOfWorkerThreads,
902: IN PWORKER_ROUTINE WorkerRoutine
903: )
904:
905: /*++
906:
907: Routine Description:
908:
909: This function creates a work queue, with the specified number of
910: threads to service work items placed in the queue. Work items
911: are removed from the queue in the same order that they are placed
912: in the queue.
913:
914: Arguments:
915:
916: NumberOfWorkerThreads - Specifies how many threads this function
917: should create to process work items placed in the queue.
918: Must be greater than 0 and less than 128.
919:
920: WorkerRoutine - Specifies the address of a routine to call
921: for each work item as it is removed from the queue. The
922: thread context the routine is called in is undefined.
923:
924: Return Value:
925:
926: A pointer to the work queue. Returns NULL if unable to create
927: the work queue and its worker threads. Extended error information
928: is available from GetLastError()
929:
930: --*/
931:
932: {
933: PWORK_QUEUE WorkQueue;
934: HANDLE Thread;
935: DWORD ThreadId;
936: DWORD i;
937:
938: //
939: // Allocate space for the work queue, which includes an
940: // array of thread handles.
941: //
942:
943: WorkQueue = LocalAlloc( LMEM_ZEROINIT,
944: sizeof( *WorkQueue ) +
945: (NumberOfWorkerThreads * sizeof( HANDLE ))
946: );
947: if (WorkQueue == NULL) {
948: return NULL;
949: }
950:
951: //
952: // The work queue is controlled by a counting semaphore that
953: // is incremented each time a work item is placed in the queue
954: // and decremented each time a worker thread wakes up to remove
955: // an item from the queue.
956: //
957:
958: if (WorkQueue->Semaphore = CreateSemaphore( NULL, 0, 1000, NULL )) {
959: //
960: // Mutual exclusion between the worker threads accessing
961: // the work queue is done with a critical section.
962: //
963:
964: InitializeCriticalSection( &WorkQueue->CriticalSection );
965:
966: //
967: // The queue itself is just a doubly linked list, where
968: // items are placed in the queue at the tail of the list
969: // and removed from the queue from the head of the list.
970: //
971:
972: InitializeListHead( &WorkQueue->Queue );
973:
974: //
975: // Removed the address of the supplied worker function
976: // in the work queue structure.
977: //
978:
979: WorkQueue->WorkerRoutine = WorkerRoutine;
980:
981: //
982: // Now create the requested number of worker threads.
983: // The handle to each thread is remembered in an
984: // array of thread handles in the work queue structure.
985: //
986:
987: for (i=0; i<NumberOfWorkerThreads; i++) {
988: Thread = CreateThread( NULL,
989: 0,
990: WorkerThread,
991: NULL,
992: 0,
993: &ThreadId
994: );
995: if (Thread == NULL) {
996: break;
997: }
998: else {
999: WorkQueue->NumberOfWorkerThreads++;
1000: WorkQueue->WorkerThreads[ i ] = Thread;
1001: }
1002: }
1003:
1004: //
1005: // If we successfully created all of the worker threads
1006: // then return the address of the work queue structure
1007: // to indicate success.
1008: //
1009:
1010: if (i == NumberOfWorkerThreads) {
1011: return WorkQueue;
1012: }
1013: }
1014:
1015: //
1016: // Failed for some reason. Destroy whatever we managed
1017: // to create and return failure to the caller.
1018: //
1019:
1020: DestroyWorkQueue( WorkQueue );
1021: return NULL;
1022: }
1023:
1024:
1025:
1026: VOID
1027: DestroyWorkQueue(
1028: IN OUT PWORK_QUEUE WorkQueue
1029: )
1030:
1031: /*++
1032:
1033: Routine Description:
1034:
1035: This function destroys a work queue created with the CreateWorkQueue
1036: functions. It attempts to shut down the worker threads cleanly
1037: by queueing a terminate work item to each worker thread. It then
1038: waits for all the worker threads to terminate. If the wait is
1039: not satisfied within 30 seconds, then it goes ahead and terminates
1040: all of the worker threads.
1041:
1042: Arguments:
1043:
1044: WorkQueue - Supplies a pointer to the work queue to destroy.
1045:
1046: Return Value:
1047:
1048: None.
1049:
1050: --*/
1051:
1052: {
1053: DWORD i;
1054: DWORD rc;
1055:
1056: //
1057: // If the semaphore handle field is not NULL, then there
1058: // may be threads to terminate.
1059: //
1060:
1061: if (WorkQueue->Semaphore != NULL) {
1062: //
1063: // Set the termiating flag in the work queue and
1064: // signal the counting semaphore by the number
1065: // worker threads so they will all wake up and
1066: // notice the terminating flag and exit.
1067: //
1068:
1069: EnterCriticalSection( &WorkQueue->CriticalSection );
1070: try {
1071: WorkQueue->Terminating = TRUE;
1072: ReleaseSemaphore( WorkQueue->Semaphore,
1073: WorkQueue->NumberOfWorkerThreads,
1074: NULL
1075: );
1076: }
1077: finally {
1078: LeaveCriticalSection( &WorkQueue->CriticalSection );
1079: }
1080:
1081: //
1082: // Wait for all worker threads to wake up and see the
1083: // terminate flag and then terminate themselves. Timeout
1084: // the wait after 30 seconds.
1085: //
1086:
1087: while (TRUE) {
1088: rc = WaitForMultipleObjectsEx( WorkQueue->NumberOfWorkerThreads,
1089: WorkQueue->WorkerThreads,
1090: TRUE,
1091: 30000,
1092: TRUE
1093: );
1094: if (rc == WAIT_IO_COMPLETION) {
1095: //
1096: // If we came out of the wait because an I/O
1097: // completion routine was called, reissue the
1098: // wait.
1099: //
1100: continue;
1101: }
1102: else {
1103: break;
1104: }
1105: }
1106:
1107: //
1108: // Now close our thread handles so they will actually
1109: // evaporate. If the wait above was unsuccessful,
1110: // then first attempt to force the termination of
1111: // each worker thread prior to closing the handle.
1112: //
1113:
1114: for (i=0; i<WorkQueue->NumberOfWorkerThreads; i++) {
1115: if (rc != NO_ERROR) {
1116: TerminateThread( WorkQueue->WorkerThreads[ i ], rc );
1117: }
1118:
1119: CloseHandle( WorkQueue->WorkerThreads[ i ] );
1120: }
1121:
1122: //
1123: // All threads stopped, all thread handles closed. Now
1124: // delete the critical section and close the semaphore
1125: // handle.
1126: //
1127:
1128: DeleteCriticalSection( &WorkQueue->CriticalSection );
1129: CloseHandle( WorkQueue->Semaphore );
1130: }
1131:
1132: //
1133: // Everything done, now free the memory used by the work queue.
1134: //
1135:
1136: LocalFree( WorkQueue );
1137: return;
1138: }
1139:
1140:
1141:
1142: BOOL
1143: QueueWorkItem(
1144: IN OUT PWORK_QUEUE WorkQueue,
1145: IN PWORK_QUEUE_ITEM WorkItem
1146: )
1147:
1148: /*++
1149:
1150: Routine Description:
1151:
1152: This function queues a work item to the passed work queue that is
1153: processed by one of the worker threads associated with the queue.
1154:
1155: Arguments:
1156:
1157: WorkQueue - Supplies a pointer to the work queue that is to
1158: receive the work item.
1159:
1160: WorkItem - Supplies a pointer to the work item to add the the queue.
1161: The work item structure contains a doubly linked list entry, the
1162: address of a routine to call and a parameter to pass to that
1163: routine. It is the routine's responsibility to reclaim the
1164: storage occupied by the WorkItem structure.
1165:
1166: Return Value:
1167:
1168: TRUE if operation was successful. Otherwise returns FALSE and
1169: extended error information is available from GetLastError()
1170:
1171: --*/
1172:
1173: {
1174: BOOL Result;
1175:
1176: //
1177: // Acquire the work queue critical section and insert the work item
1178: // in the queue and release the semaphore if the work item is not
1179: // already in the list.
1180: //
1181:
1182: EnterCriticalSection( &WorkQueue->CriticalSection );
1183: Result = TRUE;
1184: try {
1185: InsertTailList( &WorkQueue->Queue, &WorkItem->List );
1186: Result = ReleaseSemaphore( WorkQueue->Semaphore, 1, NULL );
1187: }
1188: finally {
1189: LeaveCriticalSection( &WorkQueue->CriticalSection );
1190: }
1191:
1192: return Result;
1193: }
1194:
1195:
1196:
1197: DWORD
1198: WorkerThread(
1199: LPVOID lpThreadParameter
1200: )
1201: {
1202: DWORD rc;
1203: WORK_QUEUE_ITEM InitWorkItem;
1204: PWORK_QUEUE_ITEM WorkItem;
1205:
1206: //
1207: // Call the worker routine with an initialize work item
1208: // to give it a change to initialize some per thread
1209: // state that will passed to it for each subsequent
1210: // work item.
1211: //
1212:
1213: InitWorkItem.Reason = WORK_INITIALIZE_ITEM;
1214: (WorkQueue->WorkerRoutine)( &InitWorkItem );
1215: while( TRUE ) {
1216:
1217: //
1218: // Wait until something is put in the queue (semaphore is
1219: // released), remove the item from the queue, mark it not
1220: // inserted, and execute the specified routine.
1221: //
1222:
1223: rc = WaitForSingleObjectEx( WorkQueue->Semaphore, 0xFFFFFFFF, TRUE );
1224: if (rc == WAIT_IO_COMPLETION) {
1225: continue;
1226: }
1227:
1228: EnterCriticalSection( &WorkQueue->CriticalSection );
1229: try {
1230: if (WorkQueue->Terminating && IsListEmpty( &WorkQueue->Queue )) {
1231: break;
1232: }
1233:
1234: WorkItem = (PWORK_QUEUE_ITEM)RemoveHeadList( &WorkQueue->Queue );
1235: }
1236: finally {
1237: LeaveCriticalSection( &WorkQueue->CriticalSection );
1238: }
1239:
1240: //
1241: // Execute the worker routine for this work item.
1242: //
1243:
1244: try {
1245: (WorkQueue->WorkerRoutine)( WorkItem );
1246: }
1247:
1248: except( EXCEPTION_EXECUTE_HANDLER ) {
1249: }
1250: }
1251:
1252: InitWorkItem.Reason = WORK_TERMINATE_ITEM;
1253: (WorkQueue->WorkerRoutine)( &InitWorkItem );
1254:
1255: ExitThread( 0 );
1256: return 0; // This will exit this thread
1257: }
1258:
1259:
1260: BOOL
1261: CreateVirtualBuffer(
1262: OUT PVIRTUAL_BUFFER Buffer,
1263: IN DWORD CommitSize,
1264: IN DWORD ReserveSize OPTIONAL
1265: )
1266:
1267: /*++
1268:
1269: Routine Description:
1270:
1271: This function is called to create a virtual buffer. A virtual
1272: buffer is a contiguous range of virtual memory, where some initial
1273: prefix portion of the memory is committed and the remainder is only
1274: reserved virtual address space. A routine is provided to extend the
1275: size of the committed region incrementally or to trim the size of
1276: the committed region back to some specified amount.
1277:
1278: Arguments:
1279:
1280: Buffer - Pointer to the virtual buffer control structure that is
1281: filled in by this function.
1282:
1283: CommitSize - Size of the initial committed portion of the buffer.
1284: May be zero.
1285:
1286: ReserveSize - Amount of virtual address space to reserve for the
1287: buffer. May be zero, in which case amount reserved is the
1288: committed size plus one, rounded up to the next 64KB boundary.
1289:
1290: Return Value:
1291:
1292: TRUE if operation was successful. Otherwise returns FALSE and
1293: extended error information is available from GetLastError()
1294:
1295: --*/
1296:
1297: {
1298: SYSTEM_INFO SystemInformation;
1299:
1300: //
1301: // Query the page size from the system for rounding
1302: // our memory allocations.
1303: //
1304:
1305: GetSystemInfo( &SystemInformation );
1306: Buffer->PageSize = SystemInformation.dwPageSize;
1307:
1308: //
1309: // If the reserve size was not specified, default it by
1310: // rounding up the initial committed size to a 64KB
1311: // boundary. This is because the Win32 Virtual Memory
1312: // API calls always allocate virtual address space on
1313: // 64KB boundaries, so we might well have it available
1314: // for commitment.
1315: //
1316:
1317: if (!ARGUMENT_PRESENT( ReserveSize )) {
1318: ReserveSize = ROUND_UP( CommitSize + 1, 0x10000 );
1319: }
1320:
1321: //
1322: // Attempt to reserve the address space.
1323: //
1324:
1325: Buffer->Base = VirtualAlloc( NULL,
1326: ReserveSize,
1327: MEM_RESERVE,
1328: PAGE_READWRITE
1329: );
1330: if (Buffer->Base == NULL) {
1331: //
1332: // Unable to reserve address space, return failure.
1333: //
1334:
1335: return FALSE;
1336: }
1337:
1338: //
1339: // Attempt to commit some initial portion of the reserved region.
1340: //
1341: //
1342:
1343: CommitSize = ROUND_UP( CommitSize, Buffer->PageSize );
1344: if (CommitSize == 0 ||
1345: VirtualAlloc( Buffer->Base,
1346: CommitSize,
1347: MEM_COMMIT,
1348: PAGE_READWRITE
1349: ) != NULL
1350: ) {
1351: //
1352: // Either the size of the committed region was zero or the
1353: // commitment succeeded. In either case calculate the
1354: // address of the first byte after the committed region
1355: // and the address of the first byte after the reserved
1356: // region and return successs.
1357: //
1358:
1359: Buffer->CommitLimit = (LPVOID)
1360: ((char *)Buffer->Base + CommitSize);
1361:
1362: Buffer->ReserveLimit = (LPVOID)
1363: ((char *)Buffer->Base + ReserveSize);
1364:
1365: return TRUE;
1366: }
1367:
1368: //
1369: // If unable to commit the memory, release the virtual address
1370: // range allocated above and return failure.
1371: //
1372:
1373: VirtualFree( Buffer->Base, 0, MEM_RELEASE );
1374: return FALSE;
1375: }
1376:
1377:
1378:
1379: BOOL
1380: ExtendVirtualBuffer(
1381: IN PVIRTUAL_BUFFER Buffer,
1382: IN LPVOID Address
1383: )
1384:
1385: /*++
1386:
1387: Routine Description:
1388:
1389: This function is called to extend the committed portion of a virtual
1390: buffer.
1391:
1392: Arguments:
1393:
1394: Buffer - Pointer to the virtual buffer control structure.
1395:
1396: Address - Byte at this address is committed, along with all memory
1397: from the beginning of the buffer to this address. If the
1398: address is already within the committed portion of the virtual
1399: buffer, then this routine does nothing. If outside the reserved
1400: portion of the virtual buffer, then this routine returns an
1401: error.
1402:
1403: Otherwise enough pages are committed so that the memory from the
1404: base of the buffer to the passed address is a contiguous region
1405: of committed memory.
1406:
1407:
1408: Return Value:
1409:
1410: TRUE if operation was successful. Otherwise returns FALSE and
1411: extended error information is available from GetLastError()
1412:
1413: --*/
1414:
1415: {
1416: DWORD NewCommitSize;
1417: LPVOID NewCommitLimit;
1418:
1419: //
1420: // See if address is within the buffer.
1421: //
1422:
1423: if (Address >= Buffer->Base && Address < Buffer->ReserveLimit) {
1424: //
1425: // See if the address is within the committed portion of
1426: // the buffer. If so return success immediately.
1427: //
1428:
1429: if (Address < Buffer->CommitLimit) {
1430: return TRUE;
1431: }
1432:
1433: //
1434: // Address is within the reserved portion. Determine how many
1435: // bytes are between the address and the end of the committed
1436: // portion of the buffer. Round this size to a multiple of
1437: // the page size and this is the amount we will attempt to
1438: // commit.
1439: //
1440:
1441: NewCommitSize =
1442: ((DWORD)ROUND_UP( (DWORD)Address + 1, Buffer->PageSize ) -
1443: (DWORD)Buffer->CommitLimit
1444: );
1445:
1446: //
1447: // Attempt to commit the memory.
1448: //
1449:
1450: NewCommitLimit = VirtualAlloc( Buffer->CommitLimit,
1451: NewCommitSize,
1452: MEM_COMMIT,
1453: PAGE_READWRITE
1454: );
1455: if (NewCommitLimit != NULL) {
1456: //
1457: // Successful, so update the upper limit of the committed
1458: // region of the buffer and return success.
1459: //
1460:
1461: Buffer->CommitLimit = (LPVOID)
1462: ((DWORD)NewCommitLimit + NewCommitSize);
1463:
1464: return TRUE;
1465: }
1466: }
1467:
1468: //
1469: // Address is outside of the buffer, return failure.
1470: //
1471:
1472: return FALSE;
1473: }
1474:
1475:
1476: BOOL
1477: TrimVirtualBuffer(
1478: IN PVIRTUAL_BUFFER Buffer
1479: )
1480:
1481: /*++
1482:
1483: Routine Description:
1484:
1485: This function is called to decommit any memory that has been
1486: committed for this virtual buffer.
1487:
1488: Arguments:
1489:
1490: Buffer - Pointer to the virtual buffer control structure.
1491:
1492: Return Value:
1493:
1494: TRUE if operation was successful. Otherwise returns FALSE and
1495: extended error information is available from GetLastError()
1496:
1497: --*/
1498:
1499: {
1500: Buffer->CommitLimit = Buffer->Base;
1501: return VirtualFree( Buffer->Base, 0, MEM_DECOMMIT );
1502: }
1503:
1504:
1505:
1506: BOOL
1507: FreeVirtualBuffer(
1508: IN PVIRTUAL_BUFFER Buffer
1509: )
1510: /*++
1511:
1512: Routine Description:
1513:
1514: This function is called to free all the memory that is associated
1515: with this virtual buffer.
1516:
1517: Arguments:
1518:
1519: Buffer - Pointer to the virtual buffer control structure.
1520:
1521: Return Value:
1522:
1523: TRUE if operation was successful. Otherwise returns FALSE and
1524: extended error information is available from GetLastError()
1525:
1526: --*/
1527:
1528: {
1529: //
1530: // Decommit and release all virtual memory associated with
1531: // this virtual buffer.
1532: //
1533:
1534: return VirtualFree( Buffer->Base, 0, MEM_RELEASE );
1535: }
1536:
1537:
1538:
1539: int
1540: VirtualBufferExceptionFilter(
1541: IN DWORD ExceptionCode,
1542: IN PEXCEPTION_POINTERS ExceptionInfo,
1543: IN OUT PVIRTUAL_BUFFER Buffer
1544: )
1545:
1546: /*++
1547:
1548: Routine Description:
1549:
1550: This function is an exception filter that handles exceptions that
1551: referenced uncommitted but reserved memory contained in the passed
1552: virtual buffer. It this filter routine is able to commit the
1553: additional pages needed to allow the memory reference to succeed,
1554: then it will re-execute the faulting instruction. If it is unable
1555: to commit the pages, it will execute the callers exception handler.
1556:
1557: If the exception is not an access violation or is an access
1558: violation but does not reference memory contained in the reserved
1559: portion of the virtual buffer, then this filter passes the exception
1560: on up the exception chain.
1561:
1562: Arguments:
1563:
1564: ExceptionCode - Reason for the exception.
1565:
1566: ExceptionInfo - Information about the exception and the context
1567: that it occurred in.
1568:
1569: Buffer - Points to a virtual buffer control structure that defines
1570: the reserved memory region that is to be committed whenever an
1571: attempt is made to access it.
1572:
1573: Return Value:
1574:
1575: Exception disposition code that tells the exception dispatcher what
1576: to do with this exception. One of three values is returned:
1577:
1578: EXCEPTION_EXECUTE_HANDLER - execute the exception handler
1579: associated with the exception clause that called this filter
1580: procedure.
1581:
1582: EXCEPTION_CONTINUE_SEARCH - Continue searching for an exception
1583: handler to handle this exception.
1584:
1585: EXCEPTION_CONTINUE_EXECUTION - Dismiss this exception and return
1586: control to the instruction that caused the exception.
1587:
1588:
1589: --*/
1590:
1591: {
1592: LPVOID FaultingAddress;
1593:
1594: //
1595: // If this is an access violation touching memory within
1596: // our reserved buffer, but outside of the committed portion
1597: // of the buffer, then we are going to take this exception.
1598: //
1599:
1600: if (ExceptionCode == STATUS_ACCESS_VIOLATION) {
1601: //
1602: // Get the virtual address that caused the access violation
1603: // from the exception record. Determine if the address
1604: // references memory within the reserved but uncommitted
1605: // portion of the virtual buffer.
1606: //
1607:
1608: FaultingAddress = (LPVOID)ExceptionInfo->ExceptionRecord->ExceptionInformation[ 1 ];
1609: if (FaultingAddress >= Buffer->CommitLimit &&
1610: FaultingAddress <= Buffer->ReserveLimit
1611: ) {
1612: //
1613: // This is our exception. Try to extend the buffer
1614: // to including the faulting address.
1615: //
1616:
1617: if (ExtendVirtualBuffer( Buffer, FaultingAddress )) {
1618: //
1619: // Buffer successfully extended, so re-execute the
1620: // faulting instruction.
1621: //
1622:
1623: return EXCEPTION_CONTINUE_EXECUTION;
1624: }
1625: else {
1626: //
1627: // Unable to extend the buffer. Stop searching
1628: // for exception handlers and execute the caller's
1629: // handler.
1630: //
1631:
1632: return EXCEPTION_EXECUTE_HANDLER;
1633: }
1634: }
1635: }
1636:
1637: //
1638: // Not an exception we care about, so pass it up the chain.
1639: //
1640:
1641: return EXCEPTION_CONTINUE_SEARCH;
1642: }
1643:
1644:
1645: BOOL
1646: EnumerateDirectoryTree(
1647: LPSTR DirectoryPath,
1648: PDIRECTORY_ENUMERATE_ROUTINE EnumerateRoutine,
1649: PVOID EnumerateParameter
1650: )
1651:
1652: /*++
1653:
1654: Routine Description:
1655:
1656: This function walks a directory tree, depth first, calling the
1657: passed enumeration routine for each directory and file found
1658: in the tree. The enumeration routine is passed the full path
1659: of the file, the directory information associated with the file
1660: and an enumeration parameter that is uninterpreted by this
1661: function.
1662:
1663: Arguments:
1664:
1665: DirectoryPath - Absolute or relative path to the directory that
1666: will is the root of the tree to enumerate.
1667:
1668: EnumerateRoutine - Pointer to an enumeration routine to call
1669: for each file and directory found.
1670:
1671: EnumerateParameter - Uninterpreted 32-bit value that is passed
1672: to the EnumerationRoutine each time it is called.
1673:
1674: Return Value:
1675:
1676: TRUE if operation was successful. Otherwise returns FALSE and
1677: extended error information is available from GetLastError()
1678:
1679: --*/
1680:
1681: {
1682: BOOL Result;
1683: VIRTUAL_BUFFER Buffer;
1684: PENUMERATE_DIRECTORY_STATE State;
1685: PENUMERATE_DIRECTORY_STACK Stack;
1686: WIN32_FIND_DATA FindFileData;
1687:
1688: //
1689: // Create a virtual buffer with an initial committed size of
1690: // our directory state buffer, and a maximum reserved size of
1691: // the longest possible full path based on the maximum depth
1692: // we handle and the maximum length of each path component.
1693: //
1694:
1695: if (!CreateVirtualBuffer( &Buffer,
1696: sizeof( ENUMERATE_DIRECTORY_STATE ),
1697: sizeof( ENUMERATE_DIRECTORY_STATE ) +
1698: MAX_DEPTH * MAX_PATH
1699: )
1700: ) {
1701: return FALSE;
1702: }
1703:
1704: //
1705: // This buffer will be used to maintain a stack of directory
1706: // search handles, as well as accumulate the full path string
1707: // as we descend the directory tree.
1708: //
1709:
1710: State = (PENUMERATE_DIRECTORY_STATE)Buffer.Base;
1711: State->Depth = 0;
1712: Stack = &State->Stack[ 0 ];
1713:
1714: //
1715: // Enter a try ... finally block so we can insure that we clean
1716: // up after ourselves on exit.
1717: //
1718:
1719: try {
1720: //
1721: // First translate the passed in DirectoryPath into a fully
1722: // qualified path. This path will be the initial value in
1723: // our path buffer. The initial allocation of the path buffer
1724: // is big enough for this initial request, so does not need
1725: // to be guarded by a try ... except clause.
1726: //
1727:
1728: if (GetFullPathName( DirectoryPath, MAX_PATH, State->Path, &Stack->PathEnd )) {
1729: //
1730: // Now enter a try ... except block that will be used to
1731: // manage the commitment of space in the path buffer as
1732: // we append subdirectory names and file names to it.
1733: // Using the virtual buffer allows us to handle full
1734: // path names up to 16KB in length, with an initial
1735: // allocation of 4KB.
1736: //
1737:
1738: try {
1739: //
1740: // Walk the directory tree. The outer loop is executed
1741: // once for each directory in the tree.
1742: //
1743:
1744: while (TRUE) {
1745: startDirectorySearch:
1746: //
1747: // Find the end of the current path, and make sure
1748: // there is a trailing path separator.
1749: //
1750:
1751: Stack->PathEnd = strchr( State->Path, '\0' );
1752: if (Stack->PathEnd > State->Path && Stack->PathEnd[ -1 ] != '\\') {
1753: *(Stack->PathEnd)++ = '\\';
1754: }
1755:
1756: //
1757: // Now append the wild card specification that will
1758: // let us enumerate all the entries in this directory.
1759: // Call FindFirstFile to find the first entry in the
1760: // directory.
1761: //
1762:
1763: strcpy( Stack->PathEnd, "*.*" );
1764: Stack->FindHandle = FindFirstFile( State->Path,
1765: &FindFileData
1766: );
1767: if (Stack->FindHandle != INVALID_HANDLE_VALUE) {
1768: //
1769: // Entry found. Now loop through the entire
1770: // directory processing each entry found,
1771: // including the first one.
1772: //
1773: do {
1774: //
1775: // Ignore bogus pseudo-directories that are
1776: // returned by some file systems (e.g. FAT).
1777: //
1778:
1779: if (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY &&
1780: (!strcmp( FindFileData.cFileName, "." ) ||
1781: !strcmp( FindFileData.cFileName, ".." )
1782: )
1783: ) {
1784: continue;
1785: }
1786:
1787: //
1788: // Copy the file name portion from the current
1789: // directory entry to the last component in the
1790: // path buffer.
1791: //
1792:
1793: strcpy( Stack->PathEnd, FindFileData.cFileName );
1794:
1795: //
1796: // Call the supplied enumeration routine with the
1797: // full path we have built up in the path buffer,
1798: // the directory information for this directory
1799: // entry and the supplied enumeration parameter.
1800: //
1801:
1802: (*EnumerateRoutine)( State->Path, &FindFileData, EnumerateParameter );
1803:
1804: //
1805: // If this is entry is a subdirectory, then it is
1806: // time to recurse. Do this by incrementing the
1807: // stack pointer and depth and jumping to the top
1808: // of the outer loop to process current contents
1809: // of the path buffer as a fully qualified name of
1810: // a directory.
1811: //
1812:
1813: if (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
1814: Stack++;
1815: State->Depth++;
1816: goto startDirectorySearch;
1817: restartDirectorySearch: ;
1818: }
1819:
1820: //
1821: // Here to find the next entry in the current directory.
1822: //
1823: }
1824:
1825: while ( FindNextFile( Stack->FindHandle, &FindFileData ) );
1826:
1827: //
1828: // No more entries in the current directory, so close
1829: // the search handle and fall into the code that will
1830: // pop our stack of directory seacrh handles.
1831:
1832: FindClose( Stack->FindHandle );
1833: }
1834:
1835: //
1836: // Here when done with a directory. See if we are pushed
1837: // inside another directory. If not, then we are done
1838: // enumerating the whole tree, so break out of the loop.
1839: //
1840:
1841: if (!State->Depth) {
1842: Result = TRUE;
1843: break;
1844: }
1845:
1846: //
1847: // We were pushed within another directory search,
1848: // so pop the stack to restore its search handle
1849: // and path buffer position and resume the search
1850: // within that directory.
1851:
1852: State->Depth--;
1853: --Stack;
1854: goto restartDirectorySearch;
1855: }
1856: }
1857:
1858: //
1859: // Any of the code that appends to the path buffer within
1860: // the above try ... except clause can cause an access
1861: // violation if the path buffer becomes longer than its
1862: // current committed size. This exception filter
1863: // will dynamically commit additional pages as needed
1864: // and resume execution.
1865: //
1866:
1867: except( VirtualBufferExceptionFilter( GetExceptionCode(),
1868: GetExceptionInformation(),
1869: &Buffer
1870: )
1871: ) {
1872: //
1873: // We will get here if the exception filter was unable to
1874: // commit the memory.
1875: //
1876:
1877: Result = FALSE;
1878: }
1879: }
1880: else {
1881: //
1882: // Initial GetFullPathName failed, so return a failure.
1883: //
1884:
1885: Result = FALSE;
1886: }
1887: }
1888: finally {
1889: //
1890: // Here on our way out of the outer try ... finally block.
1891: // Make sure all our search handles have been closed and then
1892: // free the virtual buffer. The only way this code is not
1893: // executed is if code within the try ... finally block
1894: // called ExitThread or ExitProcess, or an external thread
1895: // or process terminated this thread or process.
1896: //
1897: // In the case of process death, this is not a problem, because
1898: // process terminate closes all open handles attached to the process
1899: // and frees all private virtual memory that is part of the address
1900: // space of the process.
1901: //
1902: // In the case ot thread death, the code below is not executed if
1903: // the thread terminates via ExitThread in the context of the
1904: // try .. finally or if an external thread, either in this process
1905: // or another process called TerminateThread on this thread.
1906: //
1907:
1908: while (State->Depth--) {
1909: --Stack;
1910: FindClose( Stack->FindHandle );
1911: }
1912:
1913: FreeVirtualBuffer( &Buffer );
1914: }
1915:
1916: return Result;
1917: }
1918:
1919:
1920: BOOL
1921: ProcessCommandLineArguments(
1922: int argc,
1923: char *argv[]
1924: )
1925: {
1926: BOOL Result;
1927: LPSTR s;
1928:
1929: Result = FALSE;
1930: try {
1931: if (argc < 1) {
1932: return Result;
1933: }
1934:
1935: while (--argc) {
1936: s = *++argv;
1937: if (*s == '-' || *s == '/') {
1938: while (*++s) {
1939: switch( tolower( *s ) ) {
1940: case 'm':
1941: MappedFileIO = TRUE;
1942: break;
1943:
1944: case 'a':
1945: ASyncIO = TRUE;
1946: break;
1947:
1948: case 's':
1949: SyncIO = TRUE;
1950: break;
1951:
1952: case 'v':
1953: Verbose = TRUE;
1954: break;
1955:
1956: case 'y':
1957: IgnoreCase = TRUE;
1958: break;
1959:
1960: case 't':
1961: if (--argc) {
1962: NumberOfWorkerThreads = atoi( *++argv );
1963: if (NumberOfWorkerThreads > 0 && NumberOfWorkerThreads < 128) {
1964: break;
1965: }
1966: }
1967:
1968: // fall through if -t argument missing.
1969:
1970: case '?':
1971: case 'h':
1972: default:
1973: return Result;
1974: }
1975: }
1976: }
1977: else
1978: if (SearchString == NULL) {
1979: SearchString = s;
1980: }
1981: else
1982: if (DirectoryPath == NULL) {
1983: DirectoryPath = s;
1984: }
1985: else {
1986: return Result;
1987: }
1988: }
1989:
1990: if (SearchString == NULL) {
1991: return Result;
1992: }
1993:
1994: SearchStringLength = strlen( SearchString );
1995: if (SearchStringLength == 0) {
1996: return Result;
1997: }
1998:
1999: if (IgnoreCase) {
2000: SearchFunction = _strnicmp;
2001: }
2002: else {
2003: SearchFunction = strncmp;
2004: }
2005:
2006: if (DirectoryPath == NULL) {
2007: DirectoryPath = ".";
2008: }
2009:
2010: if (!(MappedFileIO || ASyncIO || SyncIO)) {
2011: MappedFileIO = TRUE;
2012: }
2013:
2014: if (Verbose) {
2015: fprintf( stderr, "Directory Tree: %s\n", DirectoryPath );
2016: fprintf( stderr, "Search String: '%s'\n", SearchString );
2017: fprintf( stderr, "Case %ssensitive\n", IgnoreCase ? "in" : "" );
2018: fprintf( stderr, "Number of Worker Threads: %u\n", NumberOfWorkerThreads );
2019: if (MappedFileIO) {
2020: fprintf( stderr, "Using Mapped File I/O\n" );
2021: }
2022: else
2023: if (ASyncIO) {
2024: fprintf( stderr, "Using ASynchronous File I/O\n" );
2025: }
2026: else
2027: if (MappedFileIO) {
2028: fprintf( stderr, "Using Synchronous File I/O\n" );
2029: }
2030: }
2031:
2032: Result = TRUE;
2033: return Result;
2034: }
2035: finally {
2036: if (!Result) {
2037: fprintf( stderr, "usage: PDC [-h] [-v] [-y] [-a | -s | -m] [-t n] SearchString [DirectoryPath]\n" );
2038: fprintf( stderr, "Where...\n" );
2039: fprintf( stderr, " -h - prints this message\n" );
2040: fprintf( stderr, " -v - generates verbose output\n" );
2041: fprintf( stderr, " -y - ignores case when doing comparision\n" );
2042: fprintf( stderr, " -t - specifies the number of threads to use (defaults to 4 * number of processors)\n" );
2043: fprintf( stderr, " -a - uses asynchronous file I/O\n" );
2044: fprintf( stderr, " -s - uses synchronous file I/O\n" );
2045: fprintf( stderr, " -m - uses mapped file I/O (default)\n" );
2046: fprintf( stderr, " SearchString - specifies the text to search for\n" );
2047: fprintf( stderr, " DirectoryPath - specifies the directory to start from (defaults to .)\n" );
2048: }
2049: }
2050: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.