开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘编程 > 查看源码
DEFRAG.C
资源名称：defrag.zip　[点击查看]
上传用户：shshsw
上传日期：2007-01-06
资源大小：37k
文件大小：18k
源码类别：

磁盘编程

开发平台：

Others

DEFRAG.C：源码内容
  1. //====================================================================
  2. //
  3. // Defrag.c
  4. //
  5. // Copyright (C) 1997 Mark Russinovich
  6. //
  7. // This program demonstrates the use of NT 4.0 FAT and NTFS cluster
  8. // movement File System Control functions.
  9. //
  10. //====================================================================
  11. #include <windows.h>
  12. #include <stdio.h>
  13. #include <conio.h>
  14. #include "defrag.h"
  16. //--------------------------------------------------------------------
  17. //                         D E F I N E S
  18. //--------------------------------------------------------------------
  20. //
  21. // Interval at which output is paused (in lines)
  22. //
  23. #define PAUSEINTERVAL 24
  25. //
  26. // Size of the buffer we read file mapping information into.
  27. // The buffer is big enough to hold the 16 bytes that 
  28. // come back at the head of the buffer (the number of entries 
  29. // and the starting virtual cluster), as well as 512 pairs
  30. // of [virtual cluster, logical cluster] pairs.
  31. //
  32. #define FILEMAPSIZE (512+2)
  34. //
  35. // Size of the bitmap buffer we pass in. Its large enough to
  36. // hold information for the 16-byte header that's returned
  37. // plus the indicated number of bytes, each of which has 8 bits 
  38. // (imagine that!)
  39. //
  40. #define BITMAPBYTES 4096
  41. #define BITMAPSIZE (BITMAPBYTES+2*sizeof(ULONGLONG))
  43. //
  44. // Invalid longlong number
  45. //
  46. #define LLINVALID ((ULONGLONG) -1)
  48. //--------------------------------------------------------------------
  49. //                        G L O B A L S
  50. //--------------------------------------------------------------------
  52. //
  53. // Handle for the raw volume that was opened
  54. //
  55. HANDLE VolumeHandle;
  57. //
  58. // Buffer to read file mapping information into
  59. //
  60. ULONGLONG FileMap[ FILEMAPSIZE ];
  62. //
  63. // Buffer thats passed to bitmap function
  64. //
  65. BYTE BitMap[ BITMAPSIZE ];
  67. //
  68. // Bit shifting array for efficient processing of the bitmap
  69. //
  70. BYTE BitShift[] = { 1, 2, 4, 8, 16, 32, 64, 128 };
  73. //--------------------------------------------------------------------
  74. //                      F U N C T I O N S
  75. //--------------------------------------------------------------------
  77. //--------------------------------------------------------------------
  78. //
  79. // PrintNtError
  80. //
  81. // Translates an NTDLL error code into its text equivalent. This
  82. // only deals with ones commonly returned by defragmenting FS Control
  83. // commands.
  84. //--------------------------------------------------------------------
  85. void PrintNtError( NTSTATUS Status )
  86. {
  87. switch( Status ) {
  88. case STATUS_SUCCESS:
  89. printf("STATUS_SUCCESSnn");
  90. break;
  91. case STATUS_INVALID_PARAMETER:
  92. printf("STATUS_INVALID_PARAMETERnn");
  93. break;
  94. case STATUS_BUFFER_TOO_SMALL:
  95. printf("STATUS_BUFFER_TOO_SMALLnn");
  96. break;
  97. case STATUS_ALREADY_COMMITTED:
  98. printf("STATUS_ALREADY_COMMITTEDnn");
  99. break;
  100. case STATUS_INVALID_DEVICE_REQUEST:
  101. printf("STATUS_INVALID_DEVICE_REQUESTnn");
  102. break;
  103. default:
  104. printf("0x%08xnn", Status );
  105. break;
  106. }   
  107. }
  110. //--------------------------------------------------------------------
  111. //
  112. // PrintWin32Error
  113. // 
  114. // Translates a Win32 error into a text equivalent
  115. //
  116. //--------------------------------------------------------------------
  117. void PrintWin32Error( DWORD ErrorCode )
  118. {
  119. LPVOID lpMsgBuf;
  120.  
  121. FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
  122. NULL, ErrorCode, 
  123. MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  124. (LPTSTR) &lpMsgBuf, 0, NULL );
  125. printf("%sn", lpMsgBuf );
  126. LocalFree( lpMsgBuf );
  127. }
  130. //--------------------------------------------------------------------
  131. //
  132. // PrintHelp
  133. //
  134. //--------------------------------------------------------------------
  135. void PrintHelp()
  136. {
  137. printf("nCommands:nn");
  138. printf("Dump bitmap free clusters:n");
  139. printf("     b [offset]n");
  140. printf("Enumerate clusters of file:n");
  141. printf("     n [filename]n");
  142. printf("Move clusters:n");
  143. printf("     m [file] [off] [tgt] [numclust]n");
  144. printf("Quit:n");
  145. printf("     qn");
  146. printf("n");
  147. }
  149. //--------------------------------------------------------------------
  150. //
  151. // PauseOutput
  152. //
  153. // After n lines have printed, stop and wait for the user to continue.
  154. // 'q' causes the function to return false.
  155. //
  156. //--------------------------------------------------------------------
  157. BOOL PauseOutput( DWORD Count ) 
  158. {
  159. char key;
  161. if( !(Count % PAUSEINTERVAL )) {
  162. printf("more ('q' to quit): "); 
  163. fflush(stdout);
  164. key = getch();
  165. printf("n");
  166. if( key == 'q' ) {
  167. printf("nEnumeration aborted.nn");
  168. return FALSE;
  169. }
  170. }
  171. return TRUE;
  172. }
  175. //--------------------------------------------------------------------
  176. //
  177. // OpenVolume
  178. //
  179. // Open the volume for defragging, a flag that is new for NT 4.0.
  180. //
  181. //--------------------------------------------------------------------
  182. DWORD OpenVolume( int DriveId ) 
  183. {
  184. static char volumeName[] = "\\.\A:";
  186. //
  187. // open the volume
  188. //
  189. volumeName[4] = DriveId + 'A'; 
  190. VolumeHandle = CreateFile( volumeName, GENERIC_READ, 
  191. FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 
  192. 0, 0 );
  193. if( VolumeHandle == INVALID_HANDLE_VALUE ) {
  195. return GetLastError();
  196. }
  198. return ERROR_SUCCESS;
  199. }
  202. //--------------------------------------------------------------------
  203. //
  204. // DumpBitmap
  205. //
  206. // Start at the offset specified (if any) and dumps all the free
  207. // clusters on the volume to the end of the volume or until
  208. // the user stops the dump with a 'q'.
  209. //
  210. //--------------------------------------------------------------------
  211. void DumpBitmap( char *argument )
  212. {
  213. DWORD status;
  214. PBITMAP_DESCRIPTOR bitMappings;
  215. ULONGLONG cluster;
  216. ULONGLONG numFree;
  217. ULONGLONG startLcn;
  218. ULONGLONG nextLcn;
  219. ULONGLONG lastLcn;
  220. IO_STATUS_BLOCK ioStatus;
  221. ULONGLONG i;
  222. int lines;
  224. //
  225. // Start scanning at the cluster offset the user specifies
  226. //
  227. bitMappings = (PBITMAP_DESCRIPTOR) BitMap;
  228. cluster = 0;
  229. nextLcn = 0;
  230. lines = 0;
  231. lastLcn = LLINVALID;
  232. sscanf( argument, " %I64d ", &nextLcn );
  233. while( !(status = NtFsControlFile( VolumeHandle, NULL, NULL, 0, &ioStatus,
  234. FSCTL_GET_VOLUME_BITMAP,
  235. &nextLcn, sizeof( cluster ),
  236. bitMappings, BITMAPSIZE )) ||
  237.  status == STATUS_BUFFER_OVERFLOW ||
  238.  status == STATUS_PENDING ) {
  240. // 
  241. // If the operation is pending, wait for it to finish
  242. //
  243. if( status == STATUS_PENDING ) {
  245. WaitForSingleObject( VolumeHandle, INFINITE );
  247. //
  248. // Get the status from the status block
  249. //
  250. if( ioStatus.Status != STATUS_SUCCESS && 
  251. ioStatus.Status != STATUS_BUFFER_OVERFLOW ) {
  253. printf("nGet Volume Bitmap: ");
  254. PrintNtError( ioStatus.Status );
  255. return;
  256. }
  257. }
  259. //
  260. // Print the range we're starting at
  261. //
  262. if( !lines ) {
  264. printf("nFree clusters starting at offset: %I64dn", 
  265. bitMappings->StartLcn );
  266. }
  268. //
  269. // Scan through the returned bitmap info, looking for empty clusters
  270. //
  271. startLcn = bitMappings->StartLcn;
  272. numFree = 0;
  273. cluster = LLINVALID;
  274. for( i = 0; i < min( bitMappings->ClustersToEndOfVol, 8*BITMAPBYTES); i++ ) {
  276. if( !(bitMappings->Map[ i/8 ] & BitShift[ i % 8 ])) {
  278. //
  279. // Cluster is free
  280. //
  281. if( cluster == LLINVALID ) {
  283. cluster = startLcn + i;
  284. numFree = 1;
  286. } else {
  288. numFree++;
  289. }
  290. } else {
  292. //
  293. // Cluster is not free
  294. //
  295. if( cluster != LLINVALID ) {
  297. if( lastLcn == cluster ) {
  299. lastLcn = LLINVALID;
  300. } else {
  302. //
  303. // See if we should continue
  304. //
  305. if( !PauseOutput( ++lines ) ) {
  307. return;
  308. }
  310. printf("   LCN: %I64d LEN: %I64dn", cluster, numFree );
  311. numFree = 0;
  312. lastLcn = cluster;
  313. cluster = LLINVALID;
  314. }
  315. } 
  316. }
  317. }
  319. //
  320. // See if we should continue
  321. //
  322. if( !PauseOutput( ++lines ) ) {
  324. return;
  325. }
  327. //
  328. // Print any remaining
  329. //
  330. if( cluster != LLINVALID && lastLcn != cluster ) {
  332. printf("   LCN: %I64d LEN: %I64dn", cluster, numFree );
  333. numFree = 0;
  334. cluster = LLINVALID;
  335. }
  337. //
  338. // End of volume?
  339. //
  340. if( status != STATUS_BUFFER_OVERFLOW ) {
  342. printf("End of volume.nn");
  343. return;
  344. }
  346. //
  347. // Move to the next block
  348. //
  349. nextLcn = bitMappings->StartLcn + i;
  350. }
  352. //
  353. // We only get here when there's an error
  354. //
  355. printf("nGet Volume Bitmap: ");
  356. PrintNtError( status );
  357. }
  360. //--------------------------------------------------------------------
  361. //
  362. // DumpFile
  363. //
  364. // Dumps the clusters belonging to the specified file until the
  365. // end of the file or the user stops the dump.
  366. //
  367. //--------------------------------------------------------------------
  368. void DumpFile( int drive, char *argument )
  369. {
  370. DWORD status;
  371. int i;
  372. HANDLE sourceFile;
  373. char fileName[MAX_PATH];
  374. IO_STATUS_BLOCK ioStatus;
  375. ULONGLONG startVcn;
  376. PGET_RETRIEVAL_DESCRIPTOR fileMappings;
  377. int lines = 0;
  379. //
  380. // Make the name into a real pathname
  381. //
  382. if( strlen( argument ) > 1 && argument[0] != '\' &&
  383. argument[0] != 'A'+drive &&
  384. argument[0] != 'a'+drive ) 
  385. sprintf(fileName, "%C:\%s", drive+'A', argument );
  386. else if( strlen( argument ) > 1 && argument[0] == '\') 
  387. sprintf(fileName, "%C:%s", drive+'A', argument );
  388. else
  389. strcpy(fileName, argument );
  391. printf("nClusters for file: %sn", fileName );
  393. //
  394. // Open the file
  395. //
  396. sourceFile = CreateFile( fileName, GENERIC_READ, 
  397. FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 
  398. FILE_FLAG_NO_BUFFERING, 0 );
  399. if( sourceFile == INVALID_HANDLE_VALUE ) {
  400. printf("Failed to open file: ");
  401. PrintWin32Error( GetLastError() );
  402. return;
  403. }
  405. //
  406. // Start dumping the mapping information. Go until we hit the end of the
  407. // file.
  408. //
  409. startVcn = 0;
  410. fileMappings = (PGET_RETRIEVAL_DESCRIPTOR) FileMap;
  411. while( !(status = NtFsControlFile( sourceFile, NULL, NULL, 0, &ioStatus,
  412. FSCTL_GET_RETRIEVAL_POINTERS,
  413. &startVcn, sizeof( startVcn ),
  414. fileMappings, FILEMAPSIZE * sizeof(LARGE_INTEGER) ) ) ||
  415.  status == STATUS_BUFFER_OVERFLOW ||
  416.  status == STATUS_PENDING ) {
  418. // 
  419. // If the operation is pending, wait for it to finish
  420. //
  421. if( status == STATUS_PENDING ) {
  423. WaitForSingleObject( sourceFile, INFINITE ); 
  425. //
  426. // Get the status from the status block
  427. //
  428. if( ioStatus.Status != STATUS_SUCCESS && 
  429. ioStatus.Status != STATUS_BUFFER_OVERFLOW ) {
  431. printf("Enumerate file clusters: ");
  432. PrintNtError( ioStatus.Status );
  433. return;
  434. }
  435. }
  437. //
  438. // Loop through the buffer of number/cluster pairs, printing them
  439. // out.
  440. //
  441. startVcn = fileMappings->StartVcn;
  442. for( i = 0; i < (ULONGLONG) fileMappings->NumberOfPairs; i++ ) {
  444. //
  445. // See if we should continue
  446. //
  447. if( !PauseOutput( ++lines ) ) {
  449. return;
  450. }  
  452. //
  453. // On NT 4.0, a compressed virtual run (0-filled) is 
  454. // identified with a cluster offset of -1
  455. //
  456. if( fileMappings->Pair[i].Lcn == LLINVALID ) {
  457. printf("   VCN: %I64d VIRTUAL LEN: %I64dn",
  458. startVcn, fileMappings->Pair[i].Vcn - startVcn ); 
  459. } else {
  460. printf("   VCN: %I64d LCN: %I64d LEN: %I64dn",
  461. startVcn, fileMappings->Pair[i].Lcn, 
  462. fileMappings->Pair[i].Vcn - startVcn );
  463. }
  464. startVcn = fileMappings->Pair[i].Vcn;
  465. }
  467. //
  468. // If the buffer wasn't overflowed, then we're done
  469. //
  470. if( !status ) break;
  471. }
  472. CloseHandle( sourceFile );
  474. //
  475. // Print any error code
  476. //
  477. printf("Enumerate file clusters: ");
  478. PrintNtError( status );
  479. }
  481. //--------------------------------------------------------------------
  482. //
  483. // MoveClusterUsage
  484. //
  485. // Prints the syntax of the demonstration program's move file command.
  486. //
  487. //--------------------------------------------------------------------
  488. void MoveClusterUsage()
  489. {
  490. printf("nMove File's syntax is:n   m [filename] [fileoffset] [target] [numclusters]nn");
  491. printf("Example:n   m c:\foo\bar 5 3455 10n");
  492. printf("   c:\foo\bar       File to moven");
  493. printf("   5                Start offset (in clusters) of the cluster in file to moven");
  494. printf("   3455             Target cluster on driven");
  495. printf("   10               Number of clusters to moven");
  496. printf("n   This would direct 10 clusters, starting at offset 5 clustersn"
  497. "   in the file, to be moved to logical cluster 3455 on the volume.nn");
  498. return;
  499. }
  501. //--------------------------------------------------------------------
  502. //
  503. // MoveCluster
  504. //
  505. // This uses the FSCT_MOVE_FILE interface to move the clusters of a
  506. // file specified by the user as arguments. MoveFile requires a 
  507. // file handle, an offset within the file, the number of sectors of
  508. // the file to move, and the target cluster on the drive to move the
  509. // clusters to.
  510. //
  511. //--------------------------------------------------------------------
  512. void MoveCluster( int drive, char *argument )
  513. {
  514. DWORD status;
  515. IO_STATUS_BLOCK ioStatus;
  516. char *argptr;
  517. HANDLE sourceFile;
  518. char fileName[MAX_PATH];
  519. LARGE_INTEGER startVcn, targetLcn;
  520. DWORD numClusters;
  521. MOVEFILE_DESCRIPTOR moveFile;
  523. //
  524. // First, we have to extract the file name
  525. //
  526. argptr = argument;
  527. while( *argptr && *argptr != ' ' ) argptr++;
  528. if( !*argptr ) {
  530. MoveClusterUsage();
  531. return; 
  532. }
  534. //
  535. // Make the name into a real pathname
  536. //
  537. *argptr = 0;
  538. if( strlen( argument ) > 1 && argument[0] != '\' &&
  539. argument[0] != 'A'+drive &&
  540. argument[0] != 'a'+drive ) 
  541. sprintf(fileName, "%C:\%s", drive+'A', argument );
  542. else if( strlen( argument ) > 1 && argument[0] == '\') 
  543. sprintf(fileName, "%C:%s", drive+'A', argument );
  544. else
  545. strcpy(fileName, argument );
  547. // 
  548. // Get numeric parameters
  549. //
  550. argument = argptr+1;
  551. if( sscanf( argument, " %I64d %I64d %d ", &startVcn, &targetLcn, &numClusters ) != 3) {
  553. MoveClusterUsage();
  554. return;
  555. }
  557. //
  558. // Tell user what we're going to try
  559. //
  560. printf("nMoving file %s:n", fileName );
  561. printf("   Start Offset: %I64dn", startVcn );
  562. printf("   Number of Clusters: %dn", numClusters );
  563. printf("   Target Cluster: %I64dn", targetLcn );
  565. //
  566. // Open the file
  567. //
  568. sourceFile = CreateFile( fileName, GENERIC_READ, 
  569. FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 
  570. FILE_FLAG_NO_BUFFERING, 0 );
  571. if( sourceFile == INVALID_HANDLE_VALUE ) {
  572. printf("Failed to open file: ");
  573. PrintWin32Error( GetLastError() );
  574. return;
  575. }
  577. //
  578. // Setup movefile descriptor and make the call
  579. //
  580. moveFile.FileHandle = sourceFile;
  581. moveFile.StartVcn = startVcn;
  582. moveFile.TargetLcn = targetLcn;
  583. moveFile.NumVcns = numClusters;
  585. status = NtFsControlFile( VolumeHandle, NULL, NULL, 0, &ioStatus,
  586. FSCTL_MOVE_FILE,
  587. &moveFile, sizeof( moveFile ),
  588. NULL, 0 );
  590. // 
  591. // If the operation is pending, wait for it to finish
  592. //
  593. if( status == STATUS_PENDING ) {
  595. WaitForSingleObject( sourceFile, INFINITE ); 
  597. status = ioStatus.Status;
  598. }
  600. //
  601. // Print status
  602. //
  603. printf("Move cluster status: ");
  604. PrintNtError( status );
  605. }
  607. //--------------------------------------------------------------------
  608. //
  609. // ExtractCommand
  610. //
  611. // Given a command line, searches for 1 character command, and then
  612. // returns a pointer to first non-whitespace following.
  613. //
  614. //--------------------------------------------------------------------
  615. char ExtractCommand( char *command, char **argument )
  616. {
  617. char cmdChar;
  619. //
  620. // Look for the command character
  621. //
  622. while( *command && *command == ' ') command++;
  624. if( !*command) return (char) 0;
  626. cmdChar = *command;
  628. command++;
  630. //
  631. // Now look for argument
  632. //
  633. while( *command && *command == ' ' ) command++;
  634. *argument = command;
  636. return cmdChar;
  637. }
  640. //--------------------------------------------------------------------
  641. //
  642. // main
  643. //
  644. // Process simple commands for enumerating the clusters of a file,
  645. // reading the volume bitmap, and moving a cluster of a particular 
  646. // file.
  647. //
  648. //--------------------------------------------------------------------
  649. int main( int argc, char *argv[])
  650. {
  651. DWORD status;
  652. int drive;
  653. char command[256];
  654. char *argument;
  655. char cmdChar;
  657. //
  658. // Get the drive to open off the command line
  659. //
  660. if( argc != 2) {
  661. printf("Usage: %s <drive letter>n", argv[0] );
  662. exit(1);
  663. }
  665. printf("nNT 4.0 Defragmentation Demonstration Program V1.0n");
  666. printf("Copyright (C) 1997 Mark Russinovichn");
  667. printf("http://www.ntinternals.comnn");
  669. if( argv[1][0] >= 'a' && argv[1][0] <= 'z' ) {
  670. drive = argv[1][0] - 'a';
  671. } else if( argv[1][0] >= 'A' && argv[1][0] <= 'Z' ) {
  672. drive = argv[1][0] - 'A';
  673. } else if( argv[1][0] == '/' ) {
  674. printf("Usage: %s <drive letter>n", argv[0] );
  675. exit(1);
  676. } else {
  677. printf("illegal drive: %cn", argv[1][0] );
  678. exit(1);
  679. }
  681. //
  682. // Get the NtFsControlFile entry point
  683. //
  684. if( !(NtFsControlFile = (void *) GetProcAddress( GetModuleHandle("ntdll.dll"),
  685. "NtFsControlFile" )) ) {
  687. printf("Could not find NtFsControlFile entry point in NTDLL.DLLn");
  688. exit(1);
  689. }
  691. //
  692. // Open the volume
  693. //
  694. printf("Opening volume: %cn", drive+'A' );
  695. status = OpenVolume(drive);
  696. printf("Open status: ");
  697. PrintWin32Error( status );
  698. if( status != ERROR_SUCCESS ) {
  700. printf("Exiting.n");
  701. exit(0);
  702. }
  704. //
  705. // Get commands 
  706. //
  707. printf("Enter commands ('?' for help):nn");
  708. while(1) {
  710. printf(": ");
  711. fflush(stdout );
  712. gets( command );
  714. cmdChar = ExtractCommand( command, &argument );
  716. switch( cmdChar ) {
  718. //
  719. // Dump bitmap information
  720. //
  721. case 'b':
  722. case 'B':
  724. DumpBitmap( argument );
  725. break;
  727. //
  728. // Help
  729. //
  730. case '?':
  731. case 'H':
  732. case 'h':
  733. PrintHelp();
  734. break;
  736. //
  737. // Move Cluster
  738. //
  739. case 'm':
  740. case 'M':
  741. MoveCluster( drive, argument );
  742. break;
  744. //
  745. // Get cluster map for file specified by name
  746. //
  747. case 'N':
  748. case 'n':
  749. DumpFile( drive, argument );
  750. break;
  752. //
  753. // Quit
  754. //
  755. case 'Q':
  756. case 'q':
  757. printf("nQuitingn");
  758. exit(0);
  759. break;
  761. case 0:
  762. break;
  764. default:
  765. printf("nInvalid commandnn");
  766. break;
  767. }
  768. }
  770. return 0;
  771. }