X-Git-Url: https://git.saurik.com/apt.git/blobdiff_plain/e9185eca390435b4060ef26c7c69d39f994da7a7..421807e1d38c58b776be0b20faed94c5316d38eb:/apt-pkg/pkgcachegen.cc diff --git a/apt-pkg/pkgcachegen.cc b/apt-pkg/pkgcachegen.cc index e7bdc615b..f9d8a8b4b 100644 --- a/apt-pkg/pkgcachegen.cc +++ b/apt-pkg/pkgcachegen.cc @@ -40,8 +40,8 @@ #include #include - -template using Dynamic = pkgCacheGenerator::Dynamic; /*}}}*/ + /*}}}*/ +template using Dynamic = pkgCacheGenerator::Dynamic; typedef std::vector::iterator FileIterator; template std::vector pkgCacheGenerator::Dynamic::toReMap; @@ -49,6 +49,7 @@ static bool IsDuplicateDescription(pkgCache::DescIterator Desc, MD5SumValue const &CurMd5, std::string const &CurLang); using std::string; +using APT::StringView; // CacheGenerator::pkgCacheGenerator - Constructor /*{{{*/ // --------------------------------------------------------------------- @@ -56,6 +57,9 @@ using std::string; pkgCacheGenerator::pkgCacheGenerator(DynamicMMap *pMap,OpProgress *Prog) : Map(*pMap), Cache(pMap,false), Progress(Prog), CurrentRlsFile(NULL), CurrentFile(NULL), d(NULL) +{ +} +bool pkgCacheGenerator::Start() { if (Map.Size() == 0) { @@ -66,7 +70,9 @@ pkgCacheGenerator::pkgCacheGenerator(DynamicMMap *pMap,OpProgress *Prog) : bool const newError = _error->PendingError(); _error->MergeWithStack(); if (newError) - return; + return false; + if (Map.Size() <= 0) + return false; Map.UsePools(*Cache.HeaderP->Pools,sizeof(Cache.HeaderP->Pools)/sizeof(Cache.HeaderP->Pools[0])); @@ -75,16 +81,15 @@ pkgCacheGenerator::pkgCacheGenerator(DynamicMMap *pMap,OpProgress *Prog) : // make room for the hashtables for packages and groups if (Map.RawAllocate(2 * (Cache.HeaderP->GetHashTableSize() * sizeof(map_pointer_t))) == 0) - return; + return false; map_stringitem_t const idxVerSysName = WriteStringInMap(_system->VS->Label); if (unlikely(idxVerSysName == 0)) - return; - Cache.HeaderP->VerSysName = idxVerSysName; + return false; map_stringitem_t const idxArchitecture = StoreString(MIXED, _config->Find("APT::Architecture")); if (unlikely(idxArchitecture == 0)) - return; - Cache.HeaderP->Architecture = idxArchitecture; + return false; + map_stringitem_t idxArchitectures; std::vector archs = APT::Configuration::getArchitectures(); if (archs.size() > 1) @@ -93,14 +98,20 @@ pkgCacheGenerator::pkgCacheGenerator(DynamicMMap *pMap,OpProgress *Prog) : std::string list = *a; for (++a; a != archs.end(); ++a) list.append(",").append(*a); - map_stringitem_t const idxArchitectures = WriteStringInMap(list); + idxArchitectures = WriteStringInMap(list); if (unlikely(idxArchitectures == 0)) - return; - Cache.HeaderP->SetArchitectures(idxArchitectures); + return false; } else - Cache.HeaderP->SetArchitectures(idxArchitecture); + idxArchitectures = idxArchitecture; + Cache.HeaderP = (pkgCache::Header *)Map.Data(); + Cache.HeaderP->VerSysName = idxVerSysName; + Cache.HeaderP->Architecture = idxArchitecture; + Cache.HeaderP->SetArchitectures(idxArchitectures); + + // Calculate the hash for the empty map, so ReMap does not fail + Cache.HeaderP->CacheFileSize = Cache.CacheHash(); Cache.ReMap(); } else @@ -109,14 +120,12 @@ pkgCacheGenerator::pkgCacheGenerator(DynamicMMap *pMap,OpProgress *Prog) : Cache.ReMap(); Map.UsePools(*Cache.HeaderP->Pools,sizeof(Cache.HeaderP->Pools)/sizeof(Cache.HeaderP->Pools[0])); if (Cache.VS != _system->VS) - { - _error->Error(_("Cache has an incompatible versioning system")); - return; - } + return _error->Error(_("Cache has an incompatible versioning system")); } Cache.HeaderP->Dirty = true; Map.Sync(0,sizeof(pkgCache::Header)); + return true; } /*}}}*/ // CacheGenerator::~pkgCacheGenerator - Destructor /*{{{*/ @@ -131,11 +140,18 @@ pkgCacheGenerator::~pkgCacheGenerator() return; Cache.HeaderP->Dirty = false; - Cache.HeaderP->CacheFileSize = Map.Size(); + Cache.HeaderP->CacheFileSize = Cache.CacheHash(); + + if (_config->FindB("Debug::pkgCacheGen", false)) + std::clog << "Produced cache with hash " << Cache.HeaderP->CacheFileSize << std::endl; Map.Sync(0,sizeof(pkgCache::Header)); } /*}}}*/ -void pkgCacheGenerator::ReMap(void const * const oldMap, void const * const newMap) {/*{{{*/ +void pkgCacheGenerator::ReMap(void const * const oldMap, void const * const newMap, size_t oldSize) {/*{{{*/ + // Prevent multiple remaps of the same iterator. If seen.insert(iterator) + // returns (something, true) the iterator was not yet seen and we can + // remap it. + std::unordered_set seen; if (oldMap == newMap) return; @@ -149,53 +165,74 @@ void pkgCacheGenerator::ReMap(void const * const oldMap, void const * const newM for (std::vector::const_iterator i = Dynamic::toReMap.begin(); i != Dynamic::toReMap.end(); ++i) - (*i)->ReMap(oldMap, newMap); + if (std::get<1>(seen.insert(*i)) == true) + (*i)->ReMap(oldMap, newMap); for (std::vector::const_iterator i = Dynamic::toReMap.begin(); i != Dynamic::toReMap.end(); ++i) - (*i)->ReMap(oldMap, newMap); + if (std::get<1>(seen.insert(*i)) == true) + (*i)->ReMap(oldMap, newMap); for (std::vector::const_iterator i = Dynamic::toReMap.begin(); i != Dynamic::toReMap.end(); ++i) - (*i)->ReMap(oldMap, newMap); + if (std::get<1>(seen.insert(*i)) == true) + (*i)->ReMap(oldMap, newMap); for (std::vector::const_iterator i = Dynamic::toReMap.begin(); i != Dynamic::toReMap.end(); ++i) - (*i)->ReMap(oldMap, newMap); + if (std::get<1>(seen.insert(*i)) == true) + (*i)->ReMap(oldMap, newMap); for (std::vector::const_iterator i = Dynamic::toReMap.begin(); i != Dynamic::toReMap.end(); ++i) - (*i)->ReMap(oldMap, newMap); + if (std::get<1>(seen.insert(*i)) == true) + (*i)->ReMap(oldMap, newMap); for (std::vector::const_iterator i = Dynamic::toReMap.begin(); i != Dynamic::toReMap.end(); ++i) - (*i)->ReMap(oldMap, newMap); + if (std::get<1>(seen.insert(*i)) == true) + (*i)->ReMap(oldMap, newMap); for (std::vector::const_iterator i = Dynamic::toReMap.begin(); i != Dynamic::toReMap.end(); ++i) - (*i)->ReMap(oldMap, newMap); + if (std::get<1>(seen.insert(*i)) == true) + (*i)->ReMap(oldMap, newMap); for (std::vector::const_iterator i = Dynamic::toReMap.begin(); i != Dynamic::toReMap.end(); ++i) - (*i)->ReMap(oldMap, newMap); + if (std::get<1>(seen.insert(*i)) == true) + (*i)->ReMap(oldMap, newMap); + for (APT::StringView* ViewP : Dynamic::toReMap) { + if (std::get<1>(seen.insert(ViewP)) == false) + continue; + // Ignore views outside of the cache. + if (ViewP->data() < static_cast(oldMap) + || ViewP->data() > static_cast(oldMap) + oldSize) + continue; + const char *data = ViewP->data() + (static_cast(newMap) - static_cast(oldMap)); + *ViewP = StringView(data , ViewP->size()); + } } /*}}}*/ // CacheGenerator::WriteStringInMap /*{{{*/ map_stringitem_t pkgCacheGenerator::WriteStringInMap(const char *String, const unsigned long &Len) { + size_t oldSize = Map.Size(); void const * const oldMap = Map.Data(); map_stringitem_t const index = Map.WriteString(String, Len); if (index != 0) - ReMap(oldMap, Map.Data()); + ReMap(oldMap, Map.Data(), oldSize); return index; } /*}}}*/ // CacheGenerator::WriteStringInMap /*{{{*/ map_stringitem_t pkgCacheGenerator::WriteStringInMap(const char *String) { + size_t oldSize = Map.Size(); void const * const oldMap = Map.Data(); map_stringitem_t const index = Map.WriteString(String); if (index != 0) - ReMap(oldMap, Map.Data()); + ReMap(oldMap, Map.Data(), oldSize); return index; } /*}}}*/ map_pointer_t pkgCacheGenerator::AllocateInMap(const unsigned long &size) {/*{{{*/ + size_t oldSize = Map.Size(); void const * const oldMap = Map.Data(); map_pointer_t const index = Map.Allocate(size); if (index != 0) - ReMap(oldMap, Map.Data()); + ReMap(oldMap, Map.Data(), oldSize); return index; } /*}}}*/ @@ -219,8 +256,10 @@ bool pkgCacheGenerator::MergeList(ListParser &List, if (Counter % 100 == 0 && Progress != 0) Progress->Progress(List.Offset()); - string Arch = List.Architecture(); - string const Version = List.Version(); + APT::StringView Arch = List.Architecture(); + Dynamic DynArch(Arch); + APT::StringView Version = List.Version(); + Dynamic DynVersion(Version); if (Version.empty() == true && Arch.empty() == true) { // package descriptions @@ -302,8 +341,6 @@ bool pkgCacheGenerator::MergeListPackage(ListParser &List, pkgCache::PkgIterator // Find the right version to write the description MD5SumValue CurMd5 = List.Description_md5(); - if (CurMd5.Value().empty() == true && List.Description("").empty() == true) - return true; std::vector availDesc = List.AvailableDescriptionLanguages(); for (Ver = Pkg.VersionList(); Ver.end() == false; ++Ver) { @@ -333,7 +370,7 @@ bool pkgCacheGenerator::MergeListPackage(ListParser &List, pkgCache::PkgIterator /*}}}*/ // CacheGenerator::MergeListVersion /*{{{*/ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator &Pkg, - std::string const &Version, pkgCache::VerIterator* &OutVer) + APT::StringView const &Version, pkgCache::VerIterator* &OutVer) { pkgCache::VerIterator Ver = Pkg.VersionList(); Dynamic DynVer(Ver); @@ -348,7 +385,9 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator int Res = 1; for (; Ver.end() == false; LastVer = &Ver->NextVer, ++Ver) { - Res = Cache.VS->CmpVersion(Version,Ver.VerStr()); + char const * const VerStr = Ver.VerStr(); + Res = Cache.VS->DoCmpVersion(Version.data(), Version.data() + Version.length(), + VerStr, VerStr + strlen(VerStr)); // Version is higher as current version - insert here if (Res > 0) break; @@ -438,8 +477,6 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator /* Record the Description(s) based on their master md5sum */ MD5SumValue CurMd5 = List.Description_md5(); - if (CurMd5.Value().empty() == true && List.Description("").empty() == true) - return true; /* Before we add a new description we first search in the group for a version with a description of the same MD5 - if so we reuse this @@ -496,8 +533,9 @@ bool pkgCacheGenerator::AddNewDescription(ListParser &List, pkgCache::VerIterato // 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) +bool pkgCacheGenerator::NewGroup(pkgCache::GrpIterator &Grp, StringView Name) { + Dynamic DName(Name); Grp = Cache.FindGrp(Name); if (Grp.end() == false) return true; @@ -516,7 +554,8 @@ bool pkgCacheGenerator::NewGroup(pkgCache::GrpIterator &Grp, const string &Name) // Insert it into the hash table unsigned long const Hash = Cache.Hash(Name); map_pointer_t *insertAt = &Cache.HeaderP->GrpHashTableP()[Hash]; - while (*insertAt != 0 && strcasecmp(Name.c_str(), Cache.StrP + (Cache.GrpP + *insertAt)->Name) > 0) + + while (*insertAt != 0 && Name.compare(Cache.ViewString((Cache.GrpP + *insertAt)->Name)) > 0) insertAt = &(Cache.GrpP + *insertAt)->Next; Grp->Next = *insertAt; *insertAt = Group; @@ -528,9 +567,11 @@ bool pkgCacheGenerator::NewGroup(pkgCache::GrpIterator &Grp, const string &Name) // CacheGenerator::NewPackage - Add a new package /*{{{*/ // --------------------------------------------------------------------- /* This creates a new package structure and adds it to the hash table */ -bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,const string &Name, - const string &Arch) { +bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg, StringView Name, + StringView Arch) { pkgCache::GrpIterator Grp; + Dynamic DName(Name); + Dynamic DArch(Arch); Dynamic DynGrp(Grp); if (unlikely(NewGroup(Grp, Name) == false)) return false; @@ -562,15 +603,14 @@ bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,const string &Name // Insert it into the hash table map_id_t const Hash = Cache.Hash(Name); map_pointer_t *insertAt = &Cache.HeaderP->PkgHashTableP()[Hash]; - while (*insertAt != 0 && strcasecmp(Name.c_str(), Cache.StrP + (Cache.GrpP + (Cache.PkgP + *insertAt)->Group)->Name) > 0) + while (*insertAt != 0 && Name.compare(Cache.StrP + (Cache.GrpP + (Cache.PkgP + *insertAt)->Group)->Name) > 0) insertAt = &(Cache.PkgP + *insertAt)->NextPackage; Pkg->NextPackage = *insertAt; *insertAt = Package; } else // Group the Packages together { - // but first get implicit provides done - if (APT::Configuration::checkArchitecture(Pkg.Arch()) == true) + // if sibling is provided by another package, this one is too { pkgCache::PkgIterator const M = Grp.FindPreferredPkg(false); // native or any foreign pkg will do if (M.end() == false) { @@ -585,22 +625,31 @@ bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,const string &Name if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed || ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign && (Prv->Flags & pkgCache::Flag::MultiArchImplicit) == 0)) + { + if (APT::Configuration::checkArchitecture(Ver.ParentPkg().Arch()) == false) + continue; if (NewProvides(Ver, Pkg, Prv->ProvideVersion, Prv->Flags) == false) return false; + } } } - - + } + // let M-A:foreign package siblings provide this package + { pkgCache::PkgIterator P; pkgCache::VerIterator Ver; Dynamic DynP(P); Dynamic DynVer(Ver); for (P = Grp.PackageList(); P.end() == false; P = Grp.NextPkg(P)) + { + if (APT::Configuration::checkArchitecture(P.Arch()) == false) + continue; for (Ver = P.VersionList(); Ver.end() == false; ++Ver) if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign) if (NewProvides(Ver, Pkg, Ver->VerStr, pkgCache::Flag::MultiArchImplicit) == false) return false; + } } // and negative dependencies, don't forget negative dependencies { @@ -634,30 +683,45 @@ bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,const string &Name // lazy-create foo (of amd64) provides foo:amd64 at the time we first need it if (Arch == "any") { - size_t const found = Name.find(':'); - std::string const NameA = Name.substr(0, found); - std::string const ArchA = Name.substr(found + 1); - pkgCache::PkgIterator PkgA = Cache.FindPkg(NameA, ArchA); - if (PkgA.end() == false) + size_t const found = Name.rfind(':'); + StringView ArchA = Name.substr(found + 1); + if (ArchA != "any") { + // ArchA is used inside the loop which might remap (NameA is not used) + Dynamic DynArchA(ArchA); + StringView NameA = Name.substr(0, found); + pkgCache::PkgIterator PkgA = Cache.FindPkg(NameA, ArchA); Dynamic DynPkgA(PkgA); - pkgCache::PrvIterator Prv = PkgA.ProvidesList(); - for (; Prv.end() == false; ++Prv) + if (PkgA.end()) { - if (Prv.IsMultiArchImplicit()) - continue; - pkgCache::VerIterator V = Prv.OwnerVer(); - if (ArchA != V.ParentPkg().Arch()) - continue; - if (NewProvides(V, Pkg, V->VerStr, pkgCache::Flag::MultiArchImplicit | pkgCache::Flag::ArchSpecific) == false) + Dynamic DynNameA(NameA); + if (NewPackage(PkgA, NameA, ArchA) == false) return false; } - pkgCache::VerIterator V = PkgA.VersionList(); - Dynamic DynV(V); - for (; V.end() == false; ++V) + if (unlikely(PkgA.end())) + return _error->Fatal("NewPackage was successful for %s:%s," + "but the package doesn't exist anyhow!", + NameA.to_string().c_str(), ArchA.to_string().c_str()); + else { - if (NewProvides(V, Pkg, V->VerStr, pkgCache::Flag::MultiArchImplicit | pkgCache::Flag::ArchSpecific) == false) - return false; + pkgCache::PrvIterator Prv = PkgA.ProvidesList(); + for (; Prv.end() == false; ++Prv) + { + if (Prv.IsMultiArchImplicit()) + continue; + pkgCache::VerIterator V = Prv.OwnerVer(); + if (ArchA != V.ParentPkg().Arch()) + continue; + if (NewProvides(V, Pkg, V->VerStr, pkgCache::Flag::MultiArchImplicit | pkgCache::Flag::ArchSpecific) == false) + return false; + } + pkgCache::VerIterator V = PkgA.VersionList(); + Dynamic DynV(V); + for (; V.end() == false; ++V) + { + if (NewProvides(V, Pkg, V->VerStr, pkgCache::Flag::MultiArchImplicit | pkgCache::Flag::ArchSpecific) == false) + return false; + } } } } @@ -669,9 +733,8 @@ bool pkgCacheGenerator::AddImplicitDepends(pkgCache::GrpIterator &G, pkgCache::PkgIterator &P, pkgCache::VerIterator &V) { - // copy P.Arch() into a string here as a cache remap - // in NewDepends() later may alter the pointer location - string Arch = P.Arch() == NULL ? "" : P.Arch(); + APT::StringView Arch = P.Arch() == NULL ? "" : P.Arch(); + Dynamic DynArch(Arch); map_pointer_t *OldDepLast = NULL; /* MultiArch handling introduces a lot of implicit Dependencies: - MultiArch: same → Co-Installable if they have the same version @@ -772,7 +835,7 @@ bool pkgCacheGenerator::NewFileVer(pkgCache::VerIterator &Ver, // --------------------------------------------------------------------- /* This puts a version structure in the linked list */ map_pointer_t pkgCacheGenerator::NewVersion(pkgCache::VerIterator &Ver, - const string &VerStr, + APT::StringView const &VerStr, map_pointer_t const ParentPkg, unsigned short const Hash, map_pointer_t const Next) @@ -801,8 +864,8 @@ map_pointer_t pkgCacheGenerator::NewVersion(pkgCache::VerIterator &Ver, continue; for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; ++V) { - int const cmp = strcmp(V.VerStr(), VerStr.c_str()); - if (cmp == 0) + int const cmp = strncmp(V.VerStr(), VerStr.data(), VerStr.length()); + if (cmp == 0 && V.VerStr()[VerStr.length()] == '\0') { Ver->VerStr = V->VerStr; return Version; @@ -992,14 +1055,17 @@ bool pkgCacheGenerator::NewDepends(pkgCache::PkgIterator &Pkg, /* This creates a Group and the Package to link this dependency to if needed and handles also the caching of the old endpoint */ bool pkgCacheListParser::NewDepends(pkgCache::VerIterator &Ver, - const string &PackageName, - const string &Arch, - const string &Version, + StringView PackageName, + StringView Arch, + StringView Version, uint8_t const Op, uint8_t const Type) { pkgCache::GrpIterator Grp; Dynamic DynGrp(Grp); + Dynamic DynPackageName(PackageName); + Dynamic DynArch(Arch); + Dynamic DynVersion(Version); if (unlikely(Owner->NewGroup(Grp, PackageName) == false)) return false; @@ -1008,7 +1074,7 @@ bool pkgCacheListParser::NewDepends(pkgCache::VerIterator &Ver, { int const CmpOp = Op & 0x0F; // =-deps are used (79:1) for lockstep on same-source packages (e.g. data-packages) - if (CmpOp == pkgCache::Dep::Equals && strcmp(Version.c_str(), Ver.VerStr()) == 0) + if (CmpOp == pkgCache::Dep::Equals && Version == Ver.VerStr()) idxVersion = Ver->VerStr; if (idxVersion == 0) @@ -1061,12 +1127,15 @@ bool pkgCacheListParser::NewDepends(pkgCache::VerIterator &Ver, /*}}}*/ // ListParser::NewProvides - Create a Provides element /*{{{*/ bool pkgCacheListParser::NewProvides(pkgCache::VerIterator &Ver, - const string &PkgName, - const string &PkgArch, - const string &Version, + StringView PkgName, + StringView PkgArch, + StringView Version, uint8_t const Flags) { pkgCache const &Cache = Owner->Cache; + Dynamic DynPkgName(PkgName); + Dynamic DynArch(PkgArch); + Dynamic DynVersion(Version); // We do not add self referencing provides if (Ver.ParentPkg().Name() == PkgName && (PkgArch == Ver.ParentPkg().Arch() || @@ -1115,11 +1184,13 @@ bool pkgCacheGenerator::NewProvides(pkgCache::VerIterator &Ver, } /*}}}*/ // ListParser::NewProvidesAllArch - add provides for all architectures /*{{{*/ -bool pkgCacheListParser::NewProvidesAllArch(pkgCache::VerIterator &Ver, string const &Package, - string const &Version, uint8_t const Flags) { +bool pkgCacheListParser::NewProvidesAllArch(pkgCache::VerIterator &Ver, StringView Package, + StringView Version, uint8_t const Flags) { pkgCache &Cache = Owner->Cache; pkgCache::GrpIterator Grp = Cache.FindGrp(Package); Dynamic DynGrp(Grp); + Dynamic DynPackage(Package); + Dynamic DynVersion(Version); if (Grp.end() == true) return NewProvides(Ver, Package, Cache.NativeArch(), Version, Flags); @@ -1251,23 +1322,21 @@ bool pkgCacheGenerator::SelectFile(std::string const &File, map_stringitem_t pkgCacheGenerator::StoreString(enum StringType const type, const char *S, unsigned int Size) { - std::string const key(S, Size); - - std::unordered_map * strings; + auto strings = &strMixed; switch(type) { case MIXED: strings = &strMixed; break; case PKGNAME: strings = &strPkgNames; break; case VERSIONNUMBER: strings = &strVersions; break; case SECTION: strings = &strSections; break; - default: _error->Fatal("Unknown enum type used for string storage of '%s'", key.c_str()); return 0; + default: _error->Fatal("Unknown enum type used for string storage of '%.*s'", Size, S); return 0; } - std::unordered_map::const_iterator const item = strings->find(key); + auto const item = strings->find({S, Size, nullptr, 0}); if (item != strings->end()) - return item->second; + return item->item; map_stringitem_t const idxString = WriteStringInMap(S,Size); - strings->insert(std::make_pair(key, idxString)); + strings->insert({nullptr, Size, this, idxString}); return idxString; } /*}}}*/ @@ -1285,7 +1354,8 @@ static bool CheckValidity(const string &CacheFile, pkgSourceList &List, FileIterator const Start, FileIterator const End, - MMap **OutMap = 0) + MMap **OutMap = 0, + pkgCache **OutCache = 0) { ScopedErrorRevert ser; bool const Debug = _config->FindB("Debug::pkgCacheGen", false); @@ -1309,7 +1379,8 @@ static bool CheckValidity(const string &CacheFile, std::unique_ptr Map(new MMap(CacheF,0)); if (unlikely(Map->validData()) == false) return false; - pkgCache Cache(Map.get()); + std::unique_ptr CacheP(new pkgCache(Map.get())); + pkgCache &Cache = *CacheP.get(); if (_error->PendingError() || Map->Size() == 0) { if (Debug == true) @@ -1399,6 +1470,8 @@ static bool CheckValidity(const string &CacheFile, if (OutMap != 0) *OutMap = Map.release(); + if (OutCache != 0) + *OutCache = CacheP.release(); return true; } /*}}}*/ @@ -1526,15 +1599,14 @@ static bool writeBackMMapToFile(pkgCacheGenerator * const Gen, DynamicMMap * con // Write out the main data if (SCacheF.Write(Map->Data(),Map->Size()) == false) return _error->Error(_("IO Error saving source cache")); - SCacheF.Sync(); // Write out the proper header Gen->GetCache().HeaderP->Dirty = false; + Gen->GetCache().HeaderP->CacheFileSize = Gen->GetCache().CacheHash(); if (SCacheF.Seek(0) == false || SCacheF.Write(Map->Data(),sizeof(*Gen->GetCache().HeaderP)) == false) return _error->Error(_("IO Error saving source cache")); Gen->GetCache().HeaderP->Dirty = true; - SCacheF.Sync(); return true; } static bool loadBackMMapFromFile(std::unique_ptr &Gen, @@ -1555,13 +1627,18 @@ static bool loadBackMMapFromFile(std::unique_ptr &Gen, if (CacheF.Read((unsigned char *)Map->Data() + alloc, CacheF.Size()) == false) return false; Gen.reset(new pkgCacheGenerator(Map.get(),Progress)); - return true; + return Gen->Start(); } bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress, MMap **OutMap, bool AllowMem) { return pkgCacheGenerator::MakeStatusCache(List, &Progress, OutMap, AllowMem); } bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress, MMap **OutMap,bool) +{ + return pkgCacheGenerator::MakeStatusCache(List, Progress, OutMap, nullptr, true); +} +bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress, + MMap **OutMap,pkgCache **OutCache, bool) { // FIXME: deprecate the ignored AllowMem parameter bool const Debug = _config->FindB("Debug::pkgCacheGen", false); @@ -1594,7 +1671,8 @@ bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress bool srcpkgcache_fine = false; bool volatile_fine = List.GetVolatileFiles().empty(); - if (CheckValidity(CacheFile, List, Files.begin(), Files.end(), volatile_fine ? OutMap : NULL) == true) + if (CheckValidity(CacheFile, List, Files.begin(), Files.end(), volatile_fine ? OutMap : NULL, + volatile_fine ? OutCache : NULL) == true) { if (Debug == true) std::clog << "pkgcache.bin is valid - no need to build any cache" << std::endl; @@ -1655,6 +1733,8 @@ bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress if (Debug == true) std::clog << "srcpkgcache.bin is NOT valid - rebuild" << std::endl; Gen.reset(new pkgCacheGenerator(Map.get(),Progress)); + if (Gen->Start() == false) + return false; TotalSize += ComputeSize(&List, Files.begin(),Files.end()); if (BuildCache(*Gen, Progress, CurrentSize, TotalSize, &List, @@ -1680,7 +1760,7 @@ bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress } if (Debug == true) - std::clog << "Caches done. Now bring in the volatile files (if any)" << std::endl; + std::clog << "Caches done. " << (volatile_fine ? "No volatile files, so we are done here." : "Now bring in the volatile files") << std::endl; if (volatile_fine == false) { @@ -1732,7 +1812,7 @@ bool pkgCacheGenerator::MakeOnlyStatusCache(OpProgress *Progress,DynamicMMap **O if (Progress != NULL) Progress->OverallProgress(0,1,1,_("Reading package lists")); pkgCacheGenerator Gen(Map.get(),Progress); - if (_error->PendingError() == true) + if (Gen.Start() == false || _error->PendingError() == true) return false; if (BuildCache(Gen,Progress,CurrentSize,TotalSize, NULL, Files.begin(), Files.end()) == false)