- Start rosapps rearrange and cleanup process.
[reactos.git] / rosapps / applications / fraginator / Unfrag.cpp
1 /*****************************************************************************
2
3 Unfrag
4
5 *****************************************************************************/
6
7
8 #include "Unfrag.h"
9 #include "DriveVolume.h"
10 #include "Defragment.h"
11 #include <process.h>
12
13
14 bool QuietMode = false;
15 bool VerboseMode = false;
16
17
18 // Makes sure we're in Windows 2000
19 bool CheckWinVer (void)
20 {
21 OSVERSIONINFO OSVersion;
22
23 ZeroMemory (&OSVersion, sizeof (OSVersion));
24 OSVersion.dwOSVersionInfoSize = sizeof (OSVersion);
25 GetVersionEx (&OSVersion);
26
27 // Need Windows 2000!
28
29 // Check for NT first
30 // Actually what we do is check that weLL're not on Win31+Win32s and that we're
31 // not in Windows 9x. It's possible that there could be more Windows "platforms"
32 // in the future and there's no sense in claiming incompatibility.
33 if (OSVersion.dwPlatformId == VER_PLATFORM_WIN32s ||
34 OSVersion.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
35 {
36 return (false);
37 }
38
39 // Ok weLL're in Windows NT, now make sure we're in 2000
40 if (OSVersion.dwMajorVersion < 5)
41 return (false);
42
43 // Kew, we're in at least Windows 2000 ("NT 5.0")
44 return (true);
45 }
46
47
48 wchar_t *AddCommas (wchar_t *Result, uint64 Number)
49 {
50 wchar_t Temp[128];
51 int TempLen;
52 //wchar_t *p = NULL;
53 int AddCommas = 0;
54 wchar_t *StrPosResult = NULL;
55 wchar_t *StrPosOrig = NULL;
56
57 // we get the string form of the number, then we count down w/ AddCommas
58 // while copying the string from Temp1 to Result. when AddCommas % 3 == 1,
59 // slap in a commas as well, before the #.
60 swprintf (Temp, L"%I64u", Number);
61 AddCommas = TempLen = wcslen (Temp);
62 StrPosOrig = Temp;
63 StrPosResult = Result;
64 while (AddCommas)
65 {
66 if ((AddCommas % 3) == 0 && AddCommas != TempLen) // avoid stuff like ",345"
67 {
68 *StrPosResult = L',';
69 StrPosResult++;
70 }
71
72 *StrPosResult = *StrPosOrig;
73 StrPosResult++;
74 StrPosOrig++;
75
76 *StrPosResult = 0;
77
78 AddCommas--;
79 }
80
81 return (Result);
82 }
83
84
85 void PrintBanner (void)
86 {
87 wprintf (L"%s v%s\n", APPNAME_CLI, APPVER_STR);
88 wprintf (L"%s\n", APPCOPYRIGHT);
89 wprintf (L"\n");
90
91 return;
92 }
93
94
95 void FraggerHelp (void)
96 {
97 wprintf (L"Usage: unfrag drive: [...] <-f | -e>\n");
98 wprintf (L"\n");
99 wprintf (L"drive: : The drive to defrag. Should be two characters long, ie 'c:' or 'd:'.\n");
100 wprintf (L" Multiple drives may be given, and all will be simultaneously\n");
101 wprintf (L" defragmented using the same options.\n");
102 wprintf (L"-f : Do a fast defragmentation. Files that are not fragmented will not be\n");
103 wprintf (L" moved. Only one pass is made over the file list. Using this option\n");
104 wprintf (L" may result in not all files being defragmented, depending on\n");
105 wprintf (L" available disk space.\n");
106 wprintf (L"-e : Do an extensive defragmention. Files will be moved in an attempt to\n");
107 wprintf (L" defragment both files and free space.\n");
108
109 if (!CheckWinVer())
110 {
111 wprintf (L"\n");
112 wprintf (L"NOTE: This program requires Windows 2000, which is not presently running on\n");
113 wprintf (L"this system.\n");
114 }
115
116 return;
117 }
118
119
120 void __cdecl DefragThread (LPVOID parm)
121 {
122 Defragment *Defrag;
123
124 Defrag = (Defragment *) parm;
125 Defrag->Start ();
126
127 _endthread ();
128 return;
129 }
130
131
132 Defragment *StartDefragThread (wstring Drive, DefragType Method, HANDLE &Handle)
133 {
134 Defragment *Defragger;
135 unsigned long Thread;
136
137 Defragger = new Defragment (Drive, Method);
138 //Thread = /*CreateThread*/ _beginthreadex (NULL, 0, DefragThread, Defragger, 0, &ThreadID);
139 Thread = _beginthread (DefragThread, 0, Defragger);
140 Handle = *((HANDLE *)&Thread);
141 return (Defragger);
142 }
143
144
145 // Main Initialization
146 int wmain (int argc, wchar_t **argv)
147 {
148 vector<wstring> Drives;
149 vector<Defragment *> Defrags;
150 DefragType DefragMode = DefragInvalid;
151
152 PrintBanner ();
153
154 // Parse command line arguments
155 bool ValidCmdLine = false;
156 for (int c = 0; c < argc; c++)
157 {
158 if (wcslen(argv[c]) == 2 && argv[c][1] == L':')
159 {
160 Drives.push_back (wcsupr(argv[c]));
161 }
162 else
163 if (argv[c][0] == L'-' || argv[c][0] == L'/' && wcslen(argv[c]) == 2)
164 {
165 switch (tolower(argv[c][1]))
166 {
167 case L'?' :
168 case L'h' :
169 FraggerHelp ();
170 return (0);
171
172 case L'f' :
173 if (DefragMode != DefragInvalid)
174 {
175 ValidCmdLine = false;
176 break;
177 }
178 DefragMode = DefragFast;
179 ValidCmdLine = true;
180 break;
181
182 case L'e' :
183 if (DefragMode != DefragInvalid)
184 {
185 ValidCmdLine = false;
186 break;
187 }
188 DefragMode = DefragExtensive;
189 ValidCmdLine = true;
190 break;
191
192 }
193 }
194 }
195
196 if (DefragMode == DefragInvalid)
197 ValidCmdLine = false;
198
199 if (!ValidCmdLine)
200 {
201 wprintf (L"Invalid command-line options. Use '%s -?' for help.\n", argv[0]);
202 return (0);
203 }
204
205 // Check OS requirements
206 if (!CheckWinVer())
207 {
208 wprintf (L"Fatal Error: This program requires Windows 2000.\n");
209 return (0);
210 }
211
212 for (size_t d = 0; d < Drives.size (); d++)
213 {
214 HANDLE TossMe;
215 Defrags.push_back (StartDefragThread (Drives[d], DefragMode, TossMe));
216 }
217
218 for (size_t d = 0; d < Drives.size () - 1; d++)
219 wprintf (L"\n ");
220
221 bool Continue = true;
222 HANDLE Screen;
223
224 Screen = GetStdHandle (STD_OUTPUT_HANDLE);
225 while (Continue)
226 {
227 Sleep (25);
228
229 // Get current screen coords
230 CONSOLE_SCREEN_BUFFER_INFO ScreenInfo;
231
232 GetConsoleScreenBufferInfo (Screen, &ScreenInfo);
233
234 // Now set back to the beginning
235 ScreenInfo.dwCursorPosition.X = 0;
236 ScreenInfo.dwCursorPosition.Y -= Drives.size();
237 SetConsoleCursorPosition (Screen, ScreenInfo.dwCursorPosition);
238
239 for (size_t d = 0; d < Drives.size (); d++)
240 {
241 wprintf (L"\n%6.2f%% %-70s", Defrags[d]->GetStatusPercent(), Defrags[d]->GetStatusString().c_str());
242 }
243
244 // Determine if we should keep going
245 Continue = false;
246 for (size_t d = 0; d < Drives.size (); d++)
247 {
248 if (!Defrags[d]->IsDoneYet() && !Defrags[d]->HasError())
249 Continue = true;
250 }
251 }
252
253 #if 0
254 // Loop through the drives list
255 for (int d = 0; d < Drives.size(); d++)
256 {
257 DriveVolume *Drive;
258
259 Drive = new DriveVolume;
260
261 // First thing: build a file list.
262 wprintf (L"Opening volume %s ...", Drives[d].c_str());
263 if (!Drive->Open (Drives[d]))
264 {
265 wprintf (L"FAILED\n\n");
266 delete Drive;
267 continue;
268 }
269 wprintf (L"\n");
270
271 wprintf (L" Getting drive bitmap ...");
272 if (!Drive->GetBitmap ())
273 {
274 wprintf (L"FAILED\n\n");
275 delete Drive;
276 continue;
277 }
278 wprintf (L"\n");
279
280 wprintf (L" Obtaining drive geometry ...");
281 if (!Drive->ObtainInfo ())
282 {
283 wprintf (L"FAILED\n\n");
284 delete Drive;
285 continue;
286 }
287 wprintf (L"\n");
288
289 wprintf (L" Building file database for drive %s ...", Drives[d].c_str());
290 if (!Drive->BuildFileList ())
291 {
292 wprintf (L"FAILED\n\n");
293 delete Drive;
294 continue;
295 }
296 wprintf (L"\n");
297
298 wprintf (L" %u files\n", Drive->GetDBFileCount ());
299
300 // Analyze only?
301 if (DefragMode == DefragAnalyze)
302 {
303 uint64 UsedBytes = 0; // total bytes used, with cluster size considerations
304 uint64 TotalBytes = 0; // total bytes used
305 uint64 SlackBytes = 0; // wasted space due to slack
306 uint32 Fragged = 0; // fragmented files
307
308 wprintf (L" Analyzing ...");
309 if (VerboseMode)
310 wprintf (L"\n");
311
312 for (int i = 0; i < Drive->GetDBFileCount(); i++)
313 {
314 uint64 Used;
315 uint64 Slack;
316 FileInfo Info;
317
318 Info = Drive->GetDBFile (i);
319
320 // Compute total used disk space
321 Used = ((Info.Size + Drive->GetClusterSize() - 1) / Drive->GetClusterSize()) * Drive->GetClusterSize();
322 Slack = Used - Info.Size;
323
324 UsedBytes += Used;
325 SlackBytes += Slack;
326 TotalBytes += Info.Size;
327
328 if (VerboseMode)
329 {
330 wprintf (L" %s%s, ", Drive->GetDBDir (Info.DirIndice).c_str(), Info.Name.c_str());
331
332 if (Info.Attributes.AccessDenied)
333 wprintf (L"access was denied\n");
334 else
335 {
336 if (Info.Attributes.Unmovable == 1)
337 wprintf (L"unmovable, ");
338
339 wprintf (L"%I64u bytes, %I64u bytes on disk, %I64u bytes slack, %u fragments\n",
340 Info.Size, Used, Slack, Info.Fragments.size());
341 }
342 }
343
344 if (Info.Fragments.size() > 1)
345 Fragged++;
346 }
347
348 if (!VerboseMode)
349 wprintf (L"\n");
350
351 // TODO: Make it not look like ass
352 wprintf (L"\n");
353 wprintf (L" Overall Analysis\n");
354 wprintf (L" ----------------\n");
355 wprintf (L" %u clusters\n", Drive->GetClusterCount ());
356 wprintf (L" %u bytes per cluster\n", Drive->GetClusterSize());
357 wprintf (L" %I64u total bytes on drive\n", (uint64)Drive->GetClusterCount() * (uint64)Drive->GetClusterSize());
358 wprintf (L"\n");
359 wprintf (L" %u files\n", Drive->GetDBFileCount ());
360 wprintf (L" %u contiguous files\n", Drive->GetDBFileCount () - Fragged);
361 wprintf (L" %u fragmented files\n", Fragged);
362 wprintf (L"\n");
363 wprintf (L" %I64u bytes\n", TotalBytes);
364 wprintf (L" %I64u bytes on disk\n", UsedBytes);
365 wprintf (L" %I64u bytes slack\n", SlackBytes);
366 }
367
368 // Fast defragment!
369 if (DefragMode == DefragFast || DefragMode == DefragExtensive)
370 {
371 uint32 i;
372 uint64 FirstFreeLCN;
373 wchar_t PrintName[80];
374 int Width = 66;
375
376 if (DefragMode == DefragFast)
377 wprintf (L" Performing fast file defragmentation ...\n");
378 else
379 if (DefragMode == DefragExtensive)
380 wprintf (L" Performing extensive file defragmentation\n");
381
382 // Find first free LCN for speedier searches ...
383 Drive->FindFreeRange (0, 1, FirstFreeLCN);
384
385 for (i = 0; i < Drive->GetDBFileCount(); i++)
386 {
387 FileInfo Info;
388 bool Result;
389 uint64 TargetLCN;
390
391 wprintf (L"\r");
392
393 Info = Drive->GetDBFile (i);
394
395 FitName (PrintName, Drive->GetDBDir (Info.DirIndice).c_str(), Info.Name.c_str(), Width);
396 wprintf (L" %6.2f%% %-66s", (float)i / (float)Drive->GetDBFileCount() * 100.0f, PrintName);
397
398 // Can't defrag 0 byte files :)
399 if (Info.Fragments.size() == 0)
400 continue;
401
402 // If doing fast defrag, skip non-fragmented files
403 if (Info.Fragments.size() == 1 && DefragMode == DefragFast)
404 continue;
405
406 // Find a place that can fit the file
407 Result = Drive->FindFreeRange (FirstFreeLCN, Info.Clusters, TargetLCN);
408
409 // If we're doing an extensive defrag and the file is already defragmented
410 // and if its new location would be after its current location, don't
411 // move it.
412 if (DefragMode == DefragExtensive && Info.Fragments.size() == 1)
413 {
414 if (TargetLCN > Info.Fragments[0].StartLCN)
415 continue;
416 }
417
418 // Otherwise, defrag0rize it!
419 if (Result)
420 {
421 bool Success = false;
422
423 if (Drive->MoveFileDumb (i, TargetLCN))
424 Success = true;
425 else
426 { // hmm, look for another area to move it to
427 Result = Drive->FindFreeRange (TargetLCN + 1, Info.Clusters, TargetLCN);
428 if (Result)
429 {
430 if (Drive->MoveFileDumb (i, TargetLCN))
431 Success = true;
432 else
433 { // Try updating the drive bitmap
434 if (Drive->GetBitmap ())
435 {
436 Result = Drive->FindFreeRange (0, Info.Clusters, TargetLCN);
437 if (Result)
438 {
439 if (Drive->MoveFileDumb (i, TargetLCN))
440 Success = true;
441 }
442 }
443 }
444 }
445 }
446
447 if (!Success)
448 wprintf (L"\n -> failed\n");
449
450 Drive->FindFreeRange (0, 1, FirstFreeLCN);
451 }
452 }
453
454 wprintf (L"\n");
455 }
456 wprintf (L"Closing volume %s ...", Drives[d].c_str());
457 delete Drive;
458 wprintf (L"\n");
459 }
460 #endif
461
462 return (0);
463 }