modules/rosapps/applications/fraginator/Defragment.cpp

   1 #include "Defragment.h"
   2
   3
   4 // Ahh yes I ripped this from my old Findupes project :)
   5 // Fits a path name, composed of a path (i.e. "c:\blah\blah\cha\cha") and a filename ("stuff.txt")
   6 // and fits it to a given length. If it has to truncate it will first truncate from the path,
   7 // substituting in periods. So you might end up with something like:
   8 // C:\Program Files\Micro...\Register.exe
   9 int FitName (wchar_t *destination, const wchar_t *path, const wchar_t *filename, uint32 totalWidth)
  10 {
  11         uint32 pathLen=0;
  12         uint32 fnLen=0;
  13         uint32 halfTotLen=0;
  14         uint32 len4fn=0;     /* number of chars remaining for filename after path is applied */
  15         uint32 len4path=0;   /* number of chars for path before filename is applied          */
  16         wchar_t fmtStrPath[20]=L"";
  17         wchar_t fmtStrFile[20]=L"";
  18         wchar_t fmtString[40]=L"";
  19
  20     /*
  21         assert (destination != NULL);
  22         assert (path != NULL);
  23         assert (filename != NULL);
  24         assert (totalWidth != 0);
  25     */
  26
  27         pathLen = wcslen(path);
  28         fnLen = wcslen(filename);
  29         if (!(totalWidth % 2))
  30                 halfTotLen=totalWidth / 2;
  31         else
  32                 halfTotLen=(totalWidth-1) / 2;  /* -1 because otherwise (halfTotLen*2) ==
  33 (totalWidth+1) which wouldn't be good */
  34
  35         /* determine how much width the path and filename each get */
  36         if ( (pathLen >= halfTotLen) && (fnLen < halfTotLen) )
  37         {
  38                 len4fn = fnLen;
  39                 len4path = (totalWidth - len4fn);
  40         }
  41
  42         if ( (pathLen < halfTotLen) && (fnLen < halfTotLen) )
  43         {
  44                 len4fn = fnLen;
  45                 len4path = pathLen;
  46         }
  47
  48         if ( (pathLen >= halfTotLen) && (fnLen >= halfTotLen) )
  49         {
  50                 len4fn = halfTotLen;
  51                 len4path = halfTotLen;
  52         }
  53
  54         if ( (pathLen < halfTotLen) && (fnLen >= halfTotLen) )
  55         {
  56                 len4path = pathLen;
  57                 len4fn = (totalWidth - len4path);
  58         }
  59         /*
  60                 if halfTotLen was adjusted above to avoid a rounding error, give the
  61                 extra wchar_t to the filename
  62         */
  63         if (halfTotLen < (totalWidth/2)) len4path++;
  64
  65         if (pathLen > len4path) swprintf (fmtStrPath, L"%%.%ds...\\", len4path-4);
  66         else
  67                 swprintf (fmtStrPath, L"%%s");
  68
  69         if (fnLen > len4fn)     swprintf (fmtStrFile, L"%%.%ds...", len4fn-3);
  70         else
  71                 swprintf (fmtStrFile, L"%%s");
  72
  73         wcscpy (fmtString, fmtStrPath);
  74         wcscat (fmtString, fmtStrFile);
  75         /*swprintf (fmtString, L"%s%s", fmtStrPath, fmtStrFile);*/
  76         swprintf (destination, fmtString, path,filename);
  77
  78         return (1);
  79 }
  80
  81 Defragment::Defragment (wstring Name, DefragType DefragMethod)
  82 {
  83     Method = DefragMethod;
  84     DoLimitLength = true;
  85     Error = false;
  86     Done = false;
  87     PleaseStop = false;
  88     PleasePause = false;
  89     DriveName = Name;
  90     StatusPercent = 0.0f;
  91     LastBMPUpdate = GetTickCount ();
  92
  93     SetStatusString (L"Opening volume " + Name);
  94     if (!Volume.Open (Name))
  95     {
  96         SetStatusString (L"Error opening volume " + Name);
  97         Error = true;
  98         Done = true;
  99         StatusPercent = 100.0f;
 100     }
 101
 102     return;
 103 }
 104
 105
 106 Defragment::~Defragment ()
 107 {
 108     if (!IsDoneYet ())
 109     {
 110         Stop ();
 111         while (!IsDoneYet()  &&  !HasError())
 112         {
 113             SetStatusString (L"Waiting for thread to stop ...");
 114             Sleep (150);
 115         }
 116     }
 117
 118     Volume.Close ();
 119     return;
 120 }
 121
 122
 123 void Defragment::SetStatusString (wstring NewStatus)
 124 {
 125     Lock ();
 126     StatusString = NewStatus;
 127     Unlock ();
 128
 129     return;
 130 }
 131
 132
 133 wstring Defragment::GetStatusString (void)
 134 {
 135     wstring ReturnVal;
 136
 137     Lock ();
 138     ReturnVal = StatusString;
 139     Unlock ();
 140
 141     return (ReturnVal);
 142 }
 143
 144
 145 double Defragment::GetStatusPercent (void)
 146 {
 147     return (StatusPercent);
 148 }
 149
 150
 151 bool Defragment::IsDoneYet (void)
 152 {
 153     return (Done);
 154 }
 155
 156
 157 void Defragment::Start (void)
 158 {
 159     uint32 i;
 160     uint64 FirstFreeLCN;
 161     uint64 TotalClusters;
 162     uint64 ClustersProgress;
 163     wchar_t PrintName[80];
 164     int Width = 70;
 165
 166     if (Error)
 167         goto DoneDefrag;
 168
 169     // First thing: build a file list.
 170     SetStatusString (L"Getting volume bitmap");
 171     if (!Volume.GetBitmap())
 172     {
 173         SetStatusString (L"Could not get volume " + DriveName + L" bitmap");
 174         Error = true;
 175         goto DoneDefrag;
 176     }
 177
 178     LastBMPUpdate = GetTickCount ();
 179
 180     if (PleaseStop)
 181         goto DoneDefrag;
 182
 183     SetStatusString (L"Obtaining volume geometry");
 184     if (!Volume.ObtainInfo ())
 185     {
 186         SetStatusString (L"Could not obtain volume " + DriveName + L" geometry");
 187         Error = true;
 188         goto DoneDefrag;
 189     }
 190
 191     if (PleaseStop)
 192         goto DoneDefrag;
 193
 194     SetStatusString (L"Building file database for volume " + DriveName);
 195     if (!Volume.BuildFileList (PleaseStop, StatusPercent))
 196     {
 197         SetStatusString (L"Could not build file database for volume " + DriveName);
 198         Error = true;
 199         goto DoneDefrag;
 200     }
 201
 202     if (PleaseStop)
 203         goto DoneDefrag;
 204
 205     SetStatusString (L"Analyzing database for " + DriveName);
 206     TotalClusters = 0;
 207     for (i = 0; i < Volume.GetDBFileCount(); i++)
 208     {
 209         TotalClusters += Volume.GetDBFile(i).Clusters;
 210     }
 211
 212     // Defragment!
 213     ClustersProgress = 0;
 214
 215     // Find first free LCN for speedier searches ...
 216     Volume.FindFreeRange (0, 1, FirstFreeLCN);
 217
 218     if (PleaseStop)
 219         goto DoneDefrag;
 220
 221     // Analyze?
 222     if (Method == DefragAnalyze)
 223     {
 224         uint32 j;
 225
 226         Report.RootPath = Volume.GetRootPath ();
 227
 228         Report.FraggedFiles.clear ();
 229         Report.UnfraggedFiles.clear ();
 230         Report.UnmovableFiles.clear ();
 231
 232         Report.FilesCount = Volume.GetDBFileCount () - Volume.GetDBDirCount ();
 233         Report.DirsCount = Volume.GetDBDirCount ();
 234         Report.DiskSizeBytes = Volume.GetVolumeInfo().TotalBytes;
 235
 236         Report.FilesSizeClusters = 0;
 237         Report.FilesSlackBytes = 0;
 238         Report.FilesSizeBytes = 0;
 239         Report.FilesFragments = 0;
 240
 241         for (j = 0; j < Volume.GetDBFileCount(); j++)
 242         {
 243             FileInfo Info;
 244
 245             Info = Volume.GetDBFile (j);
 246
 247             Report.FilesFragments += max ((size_t)1, Info.Fragments.size()); // add 1 fragment even for 0 bytes/0 cluster files
 248
 249             if (Info.Attributes.Process == 0)
 250                 continue;
 251
 252             SetStatusString (Volume.GetDBDir (Info.DirIndice) + Info.Name);
 253
 254             Report.FilesSizeClusters += Info.Clusters;
 255             Report.FilesSizeBytes += Info.Size;
 256
 257             if (Info.Attributes.Unmovable == 1)
 258                 Report.UnmovableFiles.push_back (j);
 259
 260             if (Info.Fragments.size() > 1)
 261                 Report.FraggedFiles.push_back (j);
 262             else
 263                 Report.UnfraggedFiles.push_back (j);
 264
 265             StatusPercent = ((double)j / (double)Report.FilesCount) * 100.0f;
 266         }
 267
 268         Report.FilesSizeOnDisk = Report.FilesSizeClusters * (uint64)Volume.GetVolumeInfo().ClusterSize;
 269         Report.FilesSlackBytes = Report.FilesSizeOnDisk - Report.FilesSizeBytes;
 270         Report.AverageFragments = (double)Report.FilesFragments / (double)Report.FilesCount;
 271         Report.PercentFragged = 100.0f * ((double)(signed)Report.FraggedFiles.size() / (double)(signed)Report.FilesCount);
 272
 273         uint64 Percent;
 274         Percent = (10000 * Report.FilesSlackBytes) / Report.FilesSizeOnDisk;
 275         Report.PercentSlack = (double)(signed)Percent / 100.0f;
 276     }
 277     else
 278     // Go through all the files and ... defragment them!
 279     for (i = 0; i < Volume.GetDBFileCount(); i++)
 280     {
 281         FileInfo Info;
 282         bool Result;
 283         uint64 TargetLCN;
 284         uint64 PreviousClusters;
 285
 286         // What? They want us to pause? Oh ok.
 287         if (PleasePause)
 288         {
 289             SetStatusString (L"Paused");
 290             PleasePause = false;
 291
 292             while (PleasePause == false)
 293             {
 294                 Sleep (50);
 295             }
 296
 297             PleasePause = false;
 298         }
 299
 300         if (PleaseStop)
 301         {
 302             SetStatusString (L"Stopping");
 303             break;
 304         }
 305
 306         //
 307         Info = Volume.GetDBFile (i);
 308
 309         PreviousClusters = ClustersProgress;
 310         ClustersProgress += Info.Clusters;
 311
 312         if (Info.Attributes.Process == 0)
 313             continue;
 314
 315         if (!DoLimitLength)
 316             SetStatusString (Volume.GetDBDir (Info.DirIndice) + Info.Name);
 317         else
 318         {
 319             FitName (PrintName, Volume.GetDBDir (Info.DirIndice).c_str(), Info.Name.c_str(), Width);
 320             SetStatusString (PrintName);
 321         }
 322
 323         // Calculate percentage complete
 324         StatusPercent = 100.0f * double((double)PreviousClusters / (double)TotalClusters);
 325
 326         // Can't defrag directories yet
 327         if (Info.Attributes.Directory == 1)
 328             continue;
 329
 330         // Can't defrag 0 byte files :)
 331         if (Info.Fragments.empty())
 332             continue;
 333
 334         // If doing fast defrag, skip non-fragmented files
 335         // Note: This assumes that the extents stored in Info.Fragments
 336         //       are consolidated. I.e. we assume it is NOT the case that
 337         //       two extents account for a sequential range of (non-
 338         //       fragmented) clusters.
 339         if (Info.Fragments.size() == 1  &&  Method == DefragFast)
 340             continue;
 341
 342         // Otherwise, defrag0rize it!
 343         int Retry = 3;  // retry a few times
 344         while (Retry > 0)
 345         {
 346             // Find a place that can fit the file
 347             Result = Volume.FindFreeRange (FirstFreeLCN, Info.Clusters, TargetLCN);
 348
 349             // If yes, try moving it
 350             if (Result)
 351             {
 352                 // If we're doing an extensive defrag and the file is already defragmented
 353                 // and if its new location would be after its current location, don't
 354                 // move it.
 355                 if (Method == DefragExtensive  &&  Info.Fragments.size() == 1  &&
 356                     TargetLCN > Info.Fragments[0].StartLCN)
 357                 {
 358                     Retry = 1;
 359                 }
 360                 else
 361                 {
 362                     if (Volume.MoveFileDumb (i, TargetLCN))
 363                     {
 364                         Retry = 1; // yay, all done with this file.
 365                         Volume.FindFreeRange (0, 1, FirstFreeLCN);
 366                     }
 367                 }
 368             }
 369
 370             // New: Only update bitmap if it's older than 15 seconds
 371             if ((GetTickCount() - LastBMPUpdate) < 15000)
 372                 Retry = 1;
 373             else
 374             if (!Result  ||  Retry != 1)
 375             {   // hmm. Wait for a moment, then update the drive bitmap
 376                 //SetStatusString (L"(Reobtaining volume " + DriveName + L" bitmap)");
 377
 378                 if (!DoLimitLength)
 379                 {
 380                     SetStatusString (GetStatusString() + wstring (L" ."));
 381                 }
 382
 383                 if (Volume.GetBitmap ())
 384                 {
 385                     LastBMPUpdate = GetTickCount ();
 386
 387                     if (!DoLimitLength)
 388                         SetStatusString (Volume.GetDBDir (Info.DirIndice) + Info.Name);
 389                     else
 390                         SetStatusString (PrintName);
 391
 392                     Volume.FindFreeRange (0, 1, FirstFreeLCN);
 393                 }
 394                 else
 395                 {
 396                     SetStatusString (L"Could not re-obtain volume " + DriveName + L" bitmap");
 397                     Error = true;
 398                 }
 399             }
 400
 401             Retry--;
 402         }
 403
 404         if (Error == true)
 405             break;
 406     }
 407
 408 DoneDefrag:
 409     wstring OldStatus;
 410
 411     OldStatus = GetStatusString ();
 412     StatusPercent = 99.999999f;
 413     SetStatusString (L"Closing volume " + DriveName);
 414     Volume.Close ();
 415     StatusPercent = 100.0f;
 416
 417     // If there was an error then the wstring has already been set
 418     if (Error)
 419         SetStatusString (OldStatus);
 420     else
 421     if (PleaseStop)
 422         SetStatusString (L"Volume " + DriveName + L" defragmentation was stopped");
 423     else
 424         SetStatusString (L"Finished defragmenting " + DriveName);
 425
 426     Done = true;
 427
 428     return;
 429 }
 430
 431
 432 void Defragment::TogglePause (void)
 433 {
 434     Lock ();
 435     SetStatusString (L"Pausing ...");
 436     PleasePause = true;
 437     Unlock ();
 438
 439     return;
 440 }
 441
 442
 443 void Defragment::Stop (void)
 444 {
 445     Lock ();
 446     SetStatusString (L"Stopping ...");
 447     PleaseStop = true;
 448     Unlock ();
 449
 450     return;
 451 }
 452
 453
 454 bool Defragment::HasError (void)
 455 {
 456     return (Error);
 457 }
 458