]> git.saurik.com Git - apt.git/blobdiff - apt-pkg/pkgcachegen.cc
* apt-pkg/sourcelist.cc:
[apt.git] / apt-pkg / pkgcachegen.cc
index 037c0cb63849b51708aca353068c227ef4e8e6bb..114c9d5ed36b727686fad86752471ce0d52f3c1f 100644 (file)
@@ -22,6 +22,7 @@
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/sptr.h>
 #include <apt-pkg/pkgsystem.h>
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/sptr.h>
 #include <apt-pkg/pkgsystem.h>
+#include <apt-pkg/macros.h>
 
 #include <apt-pkg/tagfile.h>
 
 
 #include <apt-pkg/tagfile.h>
 
@@ -33,7 +34,6 @@
 #include <unistd.h>
 #include <errno.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <errno.h>
 #include <stdio.h>
-#include <system.h>
                                                                        /*}}}*/
 typedef vector<pkgIndexFile *>::iterator FileIterator;
 
                                                                        /*}}}*/
 typedef vector<pkgIndexFile *>::iterator FileIterator;
 
@@ -115,9 +115,11 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
       /* As we handle Arch all packages as architecture bounded
          we add all information to every (simulated) arch package */
       std::vector<string> genArch;
       /* As we handle Arch all packages as architecture bounded
          we add all information to every (simulated) arch package */
       std::vector<string> genArch;
-      if (List.ArchitectureAll() == true)
+      if (List.ArchitectureAll() == true) {
         genArch = APT::Configuration::getArchitectures();
         genArch = APT::Configuration::getArchitectures();
-      else
+        if (genArch.size() != 1)
+           genArch.push_back("all");
+      } else
         genArch.push_back(List.Architecture());
 
       for (std::vector<string>::const_iterator arch = genArch.begin();
         genArch.push_back(List.Architecture());
 
       for (std::vector<string>::const_iterator arch = genArch.begin();
@@ -187,17 +189,22 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
       pkgCache::VerIterator Ver = Pkg.VersionList();
       map_ptrloc *LastVer = &Pkg->VersionList;
       int Res = 1;
       pkgCache::VerIterator Ver = Pkg.VersionList();
       map_ptrloc *LastVer = &Pkg->VersionList;
       int Res = 1;
+      unsigned long const Hash = List.VersionHash();
       for (; Ver.end() == false; LastVer = &Ver->NextVer, Ver++)
       {
         Res = Cache.VS->CmpVersion(Version,Ver.VerStr());
       for (; Ver.end() == false; LastVer = &Ver->NextVer, Ver++)
       {
         Res = Cache.VS->CmpVersion(Version,Ver.VerStr());
-        if (Res >= 0)
+        // Version is higher as current version - insert here
+        if (Res > 0)
+           break;
+        // Versionstrings are equal - is hash also equal?
+        if (Res == 0 && Ver->Hash == Hash)
            break;
            break;
+        // proceed with the next till we have either the right
+        // or we found another version (which will be lower)
       }
       }
-      
-      /* We already have a version for this item, record that we
-         saw it */
-      unsigned long Hash = List.VersionHash();
-      if (Res == 0 && Ver->Hash == Hash)
+
+      /* We already have a version for this item, record that we saw it */
+      if (Res == 0 && Ver.end() == false && Ver->Hash == Hash)
       {
         if (List.UsePackage(Pkg,Ver) == false)
            return _error->Error(_("Error occurred while processing %s (UsePackage2)"),
       {
         if (List.UsePackage(Pkg,Ver) == false)
            return _error->Error(_("Error occurred while processing %s (UsePackage2)"),
@@ -216,17 +223,6 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
         }
         
         continue;
         }
         
         continue;
-      }      
-
-      // Skip to the end of the same version set.
-      if (Res == 0)
-      {
-        for (; Ver.end() == false; LastVer = &Ver->NextVer, Ver++)
-        {
-           Res = Cache.VS->CmpVersion(Version,Ver.VerStr());
-           if (Res != 0)
-              break;
-        }
       }
 
       // Add a new version
       }
 
       // Add a new version
@@ -339,29 +335,30 @@ bool pkgCacheGenerator::MergeFileProvides(ListParser &List)
 // CacheGenerator::NewGroup - Add a new group                          /*{{{*/
 // ---------------------------------------------------------------------
 /* This creates a new group structure and adds it to the hash table */
 // CacheGenerator::NewGroup - Add a new group                          /*{{{*/
 // ---------------------------------------------------------------------
 /* This creates a new group structure and adds it to the hash table */
-bool pkgCacheGenerator::NewGroup(pkgCache::GrpIterator &Grp, const string &Name) {
-       Grp = Cache.FindGrp(Name);
-       if (Grp.end() == false)
-               return true;
+bool pkgCacheGenerator::NewGroup(pkgCache::GrpIterator &Grp, const string &Name)
+{
+   Grp = Cache.FindGrp(Name);
+   if (Grp.end() == false)
+      return true;
 
 
-       // Get a structure
-       unsigned long const Group = Map.Allocate(sizeof(pkgCache::Group));
-       if (unlikely(Group == 0))
-               return false;
+   // Get a structure
+   unsigned long const Group = Map.Allocate(sizeof(pkgCache::Group));
+   if (unlikely(Group == 0))
+      return false;
 
 
-       Grp = pkgCache::GrpIterator(Cache, Cache.GrpP + Group);
-       Grp->Name = Map.WriteString(Name);
-       if (unlikely(Grp->Name == 0))
-               return false;
+   Grp = pkgCache::GrpIterator(Cache, Cache.GrpP + Group);
+   Grp->Name = Map.WriteString(Name);
+   if (unlikely(Grp->Name == 0))
+      return false;
 
 
-       // Insert it into the hash table
-       unsigned long const Hash = Cache.Hash(Name);
-       Grp->Next = Cache.HeaderP->GrpHashTable[Hash];
-       Cache.HeaderP->GrpHashTable[Hash] = Group;
+   // Insert it into the hash table
+   unsigned long const Hash = Cache.Hash(Name);
+   Grp->Next = Cache.HeaderP->GrpHashTable[Hash];
+   Cache.HeaderP->GrpHashTable[Hash] = Group;
 
 
-       Cache.HeaderP->GroupCount++;
+   Cache.HeaderP->GroupCount++;
 
 
-       return true;
+   return true;
 }
                                                                        /*}}}*/
 // CacheGenerator::NewPackage - Add a new package                      /*{{{*/
 }
                                                                        /*}}}*/
 // CacheGenerator::NewPackage - Add a new package                      /*{{{*/
@@ -383,15 +380,23 @@ bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,const string &Name
       return false;
    Pkg = pkgCache::PkgIterator(Cache,Cache.PkgP + Package);
 
       return false;
    Pkg = pkgCache::PkgIterator(Cache,Cache.PkgP + Package);
 
-   // Insert it into the hash table
-   unsigned long const Hash = Cache.Hash(Name);
-   Pkg->NextPackage = Cache.HeaderP->PkgHashTable[Hash];
-   Cache.HeaderP->PkgHashTable[Hash] = Package;
-
-   // remember the packages in the group
-   Grp->FirstPackage = Package;
-   if (Grp->LastPackage == 0)
-      Grp->LastPackage = Package;
+   // Insert the package into our package list
+   if (Grp->FirstPackage == 0) // the group is new
+   {
+      // Insert it into the hash table
+      unsigned long const Hash = Cache.Hash(Name);
+      Pkg->NextPackage = Cache.HeaderP->PkgHashTable[Hash];
+      Cache.HeaderP->PkgHashTable[Hash] = Package;
+      Grp->FirstPackage = Package;
+   }
+   else // Group the Packages together
+   {
+      // this package is the new last package
+      pkgCache::PkgIterator LastPkg(Cache, Cache.PkgP + Grp->LastPackage);
+      Pkg->NextPackage = LastPkg->NextPackage;
+      LastPkg->NextPackage = Package;
+   }
+   Grp->LastPackage = Package;
 
    // Set the name, arch and the ID
    Pkg->Name = Grp->Name;
 
    // Set the name, arch and the ID
    Pkg->Name = Grp->Name;
@@ -522,57 +527,76 @@ map_ptrloc pkgCacheGenerator::NewDescription(pkgCache::DescIterator &Desc,
 // CacheGenerator::FinishCache - do various finish operations          /*{{{*/
 // ---------------------------------------------------------------------
 /* This prepares the Cache for delivery */
 // CacheGenerator::FinishCache - do various finish operations          /*{{{*/
 // ---------------------------------------------------------------------
 /* This prepares the Cache for delivery */
-bool pkgCacheGenerator::FinishCache(OpProgress &Progress) {
-       // FIXME: add progress reporting for this operation
-       // Do we have different architectures in your groups ?
-       vector<string> archs = APT::Configuration::getArchitectures();
-       if (archs.size() > 1) {
-               // Create Conflicts in between the group
-               for (pkgCache::GrpIterator G = GetCache().GrpBegin(); G.end() != true; G++) {
-                       string const PkgName = G.Name();
-                       for (pkgCache::PkgIterator P = G.PackageList(); P.end() != true; P = G.NextPkg(P)) {
-                               for (pkgCache::VerIterator V = P.VersionList(); V.end() != true; V++) {
-                                       string const Arch = V.Arch();
-                                       map_ptrloc *OldDepLast = NULL;
-                                       /* MultiArch handling introduces a lot of implicit Dependencies:
-                                          - MultiArch: same → Co-Installable if they have the same version
-                                          - Architecture: all → Need to be Co-Installable for internal reasons
-                                          - All others conflict with all other group members */
-                                       bool const coInstall = (V->MultiArch == pkgCache::Version::All ||
-                                                               V->MultiArch == pkgCache::Version::Same);
-                                       for (vector<string>::const_iterator A = archs.begin(); A != archs.end(); ++A) {
-                                               if (*A == Arch)
-                                                       continue;
-                                               /* We allow only one installed arch at the time
-                                                  per group, therefore each group member conflicts
-                                                  with all other group members */
-                                               pkgCache::PkgIterator D = G.FindPkg(*A);
-                                               if (D.end() == true)
-                                                       continue;
-                                               if (coInstall == true) {
-                                                       // Replaces: ${self}:other ( << ${binary:Version})
-                                                       NewDepends(D, V, V.VerStr(),
-                                                                  pkgCache::Dep::Less, pkgCache::Dep::Replaces,
-                                                                  OldDepLast);
-                                                       // Breaks: ${self}:other (!= ${binary:Version})
-                                                       NewDepends(D, V, V.VerStr(),
-                                                                  pkgCache::Dep::Less, pkgCache::Dep::DpkgBreaks,
-                                                                  OldDepLast);
-                                                       NewDepends(D, V, V.VerStr(),
-                                                                  pkgCache::Dep::Greater, pkgCache::Dep::DpkgBreaks,
-                                                                  OldDepLast);
-                                               } else {
-                                                       // Conflicts: ${self}:other
-                                                       NewDepends(D, V, "",
-                                                                  pkgCache::Dep::NoOp, pkgCache::Dep::Conflicts,
-                                                                  OldDepLast);
-                                               }
-                                       }
-                               }
-                       }
-               }
-       }
-       return true;
+bool pkgCacheGenerator::FinishCache(OpProgress &Progress)
+{
+   // FIXME: add progress reporting for this operation
+   // Do we have different architectures in your groups ?
+   vector<string> archs = APT::Configuration::getArchitectures();
+   if (archs.size() > 1)
+   {
+      // Create Conflicts in between the group
+      for (pkgCache::GrpIterator G = GetCache().GrpBegin(); G.end() != true; G++)
+      {
+        string const PkgName = G.Name();
+        for (pkgCache::PkgIterator P = G.PackageList(); P.end() != true; P = G.NextPkg(P))
+        {
+           if (strcmp(P.Arch(),"all") == 0)
+              continue;
+           pkgCache::PkgIterator allPkg;
+           for (pkgCache::VerIterator V = P.VersionList(); V.end() != true; V++)
+           {
+              string const Arch = V.Arch(true);
+              map_ptrloc *OldDepLast = NULL;
+              /* MultiArch handling introduces a lot of implicit Dependencies:
+               - MultiArch: same → Co-Installable if they have the same version
+               - Architecture: all → Need to be Co-Installable for internal reasons
+               - All others conflict with all other group members */
+              bool const coInstall = (V->MultiArch == pkgCache::Version::All ||
+                                       V->MultiArch == pkgCache::Version::Same);
+              if (V->MultiArch == pkgCache::Version::All && allPkg.end() == true)
+                 allPkg = G.FindPkg("all");
+              for (vector<string>::const_iterator A = archs.begin(); A != archs.end(); ++A)
+              {
+                 if (*A == Arch)
+                    continue;
+                 /* We allow only one installed arch at the time
+                    per group, therefore each group member conflicts
+                    with all other group members */
+                 pkgCache::PkgIterator D = G.FindPkg(*A);
+                 if (D.end() == true)
+                    continue;
+                 if (coInstall == true)
+                 {
+                    // Replaces: ${self}:other ( << ${binary:Version})
+                    NewDepends(D, V, V.VerStr(),
+                               pkgCache::Dep::Less, pkgCache::Dep::Replaces,
+                               OldDepLast);
+                    // Breaks: ${self}:other (!= ${binary:Version})
+                    NewDepends(D, V, V.VerStr(),
+                               pkgCache::Dep::Less, pkgCache::Dep::DpkgBreaks,
+                               OldDepLast);
+                    NewDepends(D, V, V.VerStr(),
+                               pkgCache::Dep::Greater, pkgCache::Dep::DpkgBreaks,
+                               OldDepLast);
+                    if (V->MultiArch == pkgCache::Version::All)
+                    {
+                       // Depend on ${self}:all which does depend on nothing
+                       NewDepends(allPkg, V, V.VerStr(),
+                                  pkgCache::Dep::Equals, pkgCache::Dep::Depends,
+                                  OldDepLast);
+                    }
+                 } else {
+                       // Conflicts: ${self}:other
+                       NewDepends(D, V, "",
+                                  pkgCache::Dep::NoOp, pkgCache::Dep::Conflicts,
+                                  OldDepLast);
+                 }
+              }
+           }
+        }
+      }
+   }
+   return true;
 }
                                                                        /*}}}*/
 // CacheGenerator::NewDepends - Create a dependency element            /*{{{*/
 }
                                                                        /*}}}*/
 // CacheGenerator::NewDepends - Create a dependency element            /*{{{*/
@@ -668,13 +692,14 @@ bool pkgCacheGenerator::ListParser::NewDepends(pkgCache::VerIterator Ver,
 // ---------------------------------------------------------------------
 /* */
 bool pkgCacheGenerator::ListParser::NewProvides(pkgCache::VerIterator Ver,
 // ---------------------------------------------------------------------
 /* */
 bool pkgCacheGenerator::ListParser::NewProvides(pkgCache::VerIterator Ver,
-                                               const string &PackageName,
+                                               const string &PkgName,
+                                               const string &PkgArch,
                                                const string &Version)
 {
    pkgCache &Cache = Owner->Cache;
 
    // We do not add self referencing provides
                                                const string &Version)
 {
    pkgCache &Cache = Owner->Cache;
 
    // We do not add self referencing provides
-   if (unlikely(Ver.ParentPkg().Name() == PackageName))
+   if (Ver.ParentPkg().Name() == PkgName && PkgArch == Ver.Arch(true))
       return true;
    
    // Get a structure
       return true;
    
    // Get a structure
@@ -693,7 +718,7 @@ bool pkgCacheGenerator::ListParser::NewProvides(pkgCache::VerIterator Ver,
    
    // Locate the target package
    pkgCache::PkgIterator Pkg;
    
    // Locate the target package
    pkgCache::PkgIterator Pkg;
-   if (unlikely(Owner->NewPackage(Pkg,PackageName,string(Ver.Arch())) == false))
+   if (unlikely(Owner->NewPackage(Pkg,PkgName, PkgArch) == false))
       return false;
    
    // Link it to the package
       return false;
    
    // Link it to the package
@@ -794,16 +819,23 @@ unsigned long pkgCacheGenerator::WriteUniqString(const char *S,
 static bool CheckValidity(const string &CacheFile, FileIterator Start, 
                           FileIterator End,MMap **OutMap = 0)
 {
 static bool CheckValidity(const string &CacheFile, FileIterator Start, 
                           FileIterator End,MMap **OutMap = 0)
 {
+   bool const Debug = _config->FindB("Debug::pkgCacheGen", false);
    // No file, certainly invalid
    if (CacheFile.empty() == true || FileExists(CacheFile) == false)
    // No file, certainly invalid
    if (CacheFile.empty() == true || FileExists(CacheFile) == false)
+   {
+      if (Debug == true)
+        std::clog << "CacheFile doesn't exist" << std::endl;
       return false;
       return false;
-   
+   }
+
    // Map it
    FileFd CacheF(CacheFile,FileFd::ReadOnly);
    SPtr<MMap> Map = new MMap(CacheF,0);
    pkgCache Cache(Map);
    if (_error->PendingError() == true || Map->Size() == 0)
    {
    // Map it
    FileFd CacheF(CacheFile,FileFd::ReadOnly);
    SPtr<MMap> Map = new MMap(CacheF,0);
    pkgCache Cache(Map);
    if (_error->PendingError() == true || Map->Size() == 0)
    {
+      if (Debug == true)
+        std::clog << "Errors are pending or Map is empty()" << std::endl;
       _error->Discard();
       return false;
    }
       _error->Discard();
       return false;
    }
@@ -813,9 +845,15 @@ static bool CheckValidity(const string &CacheFile, FileIterator Start,
    SPtrArray<bool> Visited = new bool[Cache.HeaderP->PackageFileCount];
    memset(Visited,0,sizeof(*Visited)*Cache.HeaderP->PackageFileCount);
    for (; Start != End; Start++)
    SPtrArray<bool> Visited = new bool[Cache.HeaderP->PackageFileCount];
    memset(Visited,0,sizeof(*Visited)*Cache.HeaderP->PackageFileCount);
    for (; Start != End; Start++)
-   {      
+   {
+      if (Debug == true)
+        std::clog << "Checking PkgFile " << (*Start)->Describe() << ": ";
       if ((*Start)->HasPackages() == false)
       if ((*Start)->HasPackages() == false)
+      {
+         if (Debug == true)
+           std::clog << "Has NO packages" << std::endl;
         continue;
         continue;
+      }
     
       if ((*Start)->Exists() == false)
       {
     
       if ((*Start)->Exists() == false)
       {
@@ -823,23 +861,40 @@ static bool CheckValidity(const string &CacheFile, FileIterator Start,
         _error->WarningE("stat",_("Couldn't stat source package list %s"),
                          (*Start)->Describe().c_str());
 #endif
         _error->WarningE("stat",_("Couldn't stat source package list %s"),
                          (*Start)->Describe().c_str());
 #endif
+         if (Debug == true)
+           std::clog << "file doesn't exist" << std::endl;
         continue;
       }
 
       // FindInCache is also expected to do an IMS check.
       pkgCache::PkgFileIterator File = (*Start)->FindInCache(Cache);
       if (File.end() == true)
         continue;
       }
 
       // FindInCache is also expected to do an IMS check.
       pkgCache::PkgFileIterator File = (*Start)->FindInCache(Cache);
       if (File.end() == true)
+      {
+        if (Debug == true)
+           std::clog << "FindInCache returned end-Pointer" << std::endl;
         return false;
         return false;
+      }
 
       Visited[File->ID] = true;
 
       Visited[File->ID] = true;
+      if (Debug == true)
+        std::clog << "with ID " << File->ID << " is valid" << std::endl;
    }
    
    for (unsigned I = 0; I != Cache.HeaderP->PackageFileCount; I++)
       if (Visited[I] == false)
    }
    
    for (unsigned I = 0; I != Cache.HeaderP->PackageFileCount; I++)
       if (Visited[I] == false)
+      {
+        if (Debug == true)
+           std::clog << "File with ID" << I << " wasn't visited" << std::endl;
         return false;
         return false;
+      }
    
    if (_error->PendingError() == true)
    {
    
    if (_error->PendingError() == true)
    {
+      if (Debug == true)
+      {
+        std::clog << "Validity failed because of pending errors:" << std::endl;
+        _error->DumpErrors();
+      }
       _error->Discard();
       return false;
    }
       _error->Discard();
       return false;
    }
@@ -926,7 +981,8 @@ static bool BuildCache(pkgCacheGenerator &Gen,
 bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
                        MMap **OutMap,bool AllowMem)
 {
 bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
                        MMap **OutMap,bool AllowMem)
 {
-   unsigned long MapSize = _config->FindI("APT::Cache-Limit",24*1024*1024);
+   bool const Debug = _config->FindB("Debug::pkgCacheGen", false);
+   unsigned long const MapSize = _config->FindI("APT::Cache-Limit",24*1024*1024);
    
    vector<pkgIndexFile *> Files;
    for (vector<metaIndex *>::const_iterator i = List.begin();
    
    vector<pkgIndexFile *> Files;
    for (vector<metaIndex *>::const_iterator i = List.begin();
@@ -940,14 +996,27 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
          Files.push_back (*j);
    }
    
          Files.push_back (*j);
    }
    
-   unsigned long EndOfSource = Files.size();
+   unsigned long const EndOfSource = Files.size();
    if (_system->AddStatusFiles(Files) == false)
       return false;
 
    // Decide if we can write to the files..
    if (_system->AddStatusFiles(Files) == false)
       return false;
 
    // Decide if we can write to the files..
-   string CacheFile = _config->FindFile("Dir::Cache::pkgcache");
-   string SrcCacheFile = _config->FindFile("Dir::Cache::srcpkgcache");
-   
+   string const CacheFile = _config->FindFile("Dir::Cache::pkgcache");
+   string const SrcCacheFile = _config->FindFile("Dir::Cache::srcpkgcache");
+
+   // ensure the cache directory exists
+   if (CacheFile.empty() == false || SrcCacheFile.empty() == false)
+   {
+      string dir = _config->FindDir("Dir::Cache");
+      size_t const len = dir.size();
+      if (len > 5 && dir.find("/apt/", len - 6, 5) == len - 5)
+        dir = dir.substr(0, len - 5);
+      if (CacheFile.empty() == false)
+        CreateDirectory(dir, flNotFile(CacheFile));
+      if (SrcCacheFile.empty() == false)
+        CreateDirectory(dir, flNotFile(SrcCacheFile));
+   }
+
    // Decide if we can write to the cache
    bool Writeable = false;
    if (CacheFile.empty() == false)
    // Decide if we can write to the cache
    bool Writeable = false;
    if (CacheFile.empty() == false)
@@ -955,7 +1024,9 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
    else
       if (SrcCacheFile.empty() == false)
         Writeable = access(flNotFile(SrcCacheFile).c_str(),W_OK) == 0;
    else
       if (SrcCacheFile.empty() == false)
         Writeable = access(flNotFile(SrcCacheFile).c_str(),W_OK) == 0;
-   
+   if (Debug == true)
+      std::clog << "Do we have write-access to the cache files? " << (Writeable ? "YES" : "NO") << std::endl;
+
    if (Writeable == false && AllowMem == false && CacheFile.empty() == false)
       return _error->Error(_("Unable to write to %s"),flNotFile(CacheFile).c_str());
    
    if (Writeable == false && AllowMem == false && CacheFile.empty() == false)
       return _error->Error(_("Unable to write to %s"),flNotFile(CacheFile).c_str());
    
@@ -965,8 +1036,12 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
    if (CheckValidity(CacheFile,Files.begin(),Files.end(),OutMap) == true)
    {
       Progress.OverallProgress(1,1,1,_("Reading package lists"));
    if (CheckValidity(CacheFile,Files.begin(),Files.end(),OutMap) == true)
    {
       Progress.OverallProgress(1,1,1,_("Reading package lists"));
+      if (Debug == true)
+        std::clog << "pkgcache.bin is valid - no need to build anything" << std::endl;
       return true;
    }
       return true;
    }
+   else if (Debug == true)
+        std::clog << "pkgcache.bin is NOT valid" << std::endl;
    
    /* At this point we know we need to reconstruct the package cache,
       begin. */
    
    /* At this point we know we need to reconstruct the package cache,
       begin. */
@@ -980,11 +1055,15 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
       Map = new DynamicMMap(*CacheF,MMap::Public,MapSize);
       if (_error->PendingError() == true)
         return false;
       Map = new DynamicMMap(*CacheF,MMap::Public,MapSize);
       if (_error->PendingError() == true)
         return false;
+      if (Debug == true)
+        std::clog << "Open filebased MMap" << std::endl;
    }
    else
    {
       // Just build it in memory..
       Map = new DynamicMMap(0,MapSize);
    }
    else
    {
       // Just build it in memory..
       Map = new DynamicMMap(0,MapSize);
+      if (Debug == true)
+        std::clog << "Open memory Map (not filebased)" << std::endl;
    }
    
    // Lets try the source cache.
    }
    
    // Lets try the source cache.
@@ -993,16 +1072,18 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
    if (CheckValidity(SrcCacheFile,Files.begin(),
                     Files.begin()+EndOfSource) == true)
    {
    if (CheckValidity(SrcCacheFile,Files.begin(),
                     Files.begin()+EndOfSource) == true)
    {
+      if (Debug == true)
+        std::clog << "srcpkgcache.bin is valid - populate MMap with it." << std::endl;
       // Preload the map with the source cache
       FileFd SCacheF(SrcCacheFile,FileFd::ReadOnly);
       // Preload the map with the source cache
       FileFd SCacheF(SrcCacheFile,FileFd::ReadOnly);
-      unsigned long alloc = Map->RawAllocate(SCacheF.Size());
+      unsigned long const alloc = Map->RawAllocate(SCacheF.Size());
       if ((alloc == 0 && _error->PendingError())
                || SCacheF.Read((unsigned char *)Map->Data() + alloc,
                                SCacheF.Size()) == false)
         return false;
 
       TotalSize = ComputeSize(Files.begin()+EndOfSource,Files.end());
       if ((alloc == 0 && _error->PendingError())
                || SCacheF.Read((unsigned char *)Map->Data() + alloc,
                                SCacheF.Size()) == false)
         return false;
 
       TotalSize = ComputeSize(Files.begin()+EndOfSource,Files.end());
-      
+
       // Build the status cache
       pkgCacheGenerator Gen(Map.Get(),&Progress);
       if (_error->PendingError() == true)
       // Build the status cache
       pkgCacheGenerator Gen(Map.Get(),&Progress);
       if (_error->PendingError() == true)
@@ -1016,6 +1097,8 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
    }
    else
    {
    }
    else
    {
+      if (Debug == true)
+        std::clog << "srcpkgcache.bin is NOT valid - rebuild" << std::endl;
       TotalSize = ComputeSize(Files.begin(),Files.end());
       
       // Build the source cache
       TotalSize = ComputeSize(Files.begin(),Files.end());
       
       // Build the source cache
@@ -1057,6 +1140,8 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
       // FIXME: move me to a better place
       Gen.FinishCache(Progress);
    }
       // FIXME: move me to a better place
       Gen.FinishCache(Progress);
    }
+   if (Debug == true)
+      std::clog << "Caches are ready for shipping" << std::endl;
 
    if (_error->PendingError() == true)
       return false;
 
    if (_error->PendingError() == true)
       return false;