From d7e9f0779043814d6e7a4141170fa7f18cd90803 Mon Sep 17 00:00:00 2001 From: David Kalnischkies Date: Sat, 28 Aug 2021 19:22:26 +0200 Subject: Move hidden MarkPackage to a static function We can't have external users as its marked hidden and as we don't even have users outside of pkgDepCache itself we can remove the function completely from the public eye. That adds many new parameters, but it also allows to add a few more like avoiding constantly checking the debug config value. Gbp-Dch: Ignore --- apt-pkg/depcache.cc | 181 +++++++++++++++++++++++++++------------------------- 1 file changed, 93 insertions(+), 88 deletions(-) (limited to 'apt-pkg/depcache.cc') diff --git a/apt-pkg/depcache.cc b/apt-pkg/depcache.cc index dfd1e1084..8ab156220 100644 --- a/apt-pkg/depcache.cc +++ b/apt-pkg/depcache.cc @@ -125,7 +125,6 @@ int pkgDepCache::DecreaseActionGroupLevel() struct pkgDepCache::Private { std::unique_ptr inRootSetFunc; - std::vector fullyExplored; std::unique_ptr IsAVersionedKernelPackage, IsProtectedKernelPackage; }; pkgDepCache::pkgDepCache(pkgCache *const pCache, Policy *const Plcy) : group_level(0), Cache(pCache), PkgState(0), DepState(0), @@ -2201,18 +2200,17 @@ pkgDepCache::InRootSetFunc *pkgDepCache::GetCachedRootSetFunc() return d->inRootSetFunc.get(); } /*}}}*/ -bool pkgDepCache::MarkFollowsRecommends() +bool pkgDepCache::MarkFollowsRecommends() /*{{{*/ { return _config->FindB("APT::AutoRemove::RecommendsImportant", true); } - -bool pkgDepCache::MarkFollowsSuggests() + /*}}}*/ +bool pkgDepCache::MarkFollowsSuggests() /*{{{*/ { return _config->FindB("APT::AutoRemove::SuggestsImportant", true); } - -// pkgDepCache::MarkRequired - the main mark algorithm /*{{{*/ -static bool IsPkgInBoringState(pkgCache::PkgIterator const &Pkg, pkgDepCache::StateCache const * const PkgState) + /*}}}*/ +static bool IsPkgInBoringState(pkgCache::PkgIterator const &Pkg, pkgDepCache::StateCache const * const PkgState)/*{{{*/ { if (Pkg->CurrentVer == 0) { @@ -2225,82 +2223,32 @@ static bool IsPkgInBoringState(pkgCache::PkgIterator const &Pkg, pkgDepCache::St return true; } return false; -} -bool pkgDepCache::MarkRequired(InRootSetFunc &userFunc) -{ - if (_config->Find("APT::Solver", "internal") != "internal") - return true; - - bool const debug_autoremove = _config->FindB("Debug::pkgAutoRemove",false); - - // init the states - auto const PackagesCount = Head().PackageCount; - for(auto i = decltype(PackagesCount){0}; i < PackagesCount; ++i) - { - PkgState[i].Marked = false; - PkgState[i].Garbage = false; - } - d->fullyExplored = std::vector(PackagesCount, false); - if (debug_autoremove) - for(PkgIterator p = PkgBegin(); !p.end(); ++p) - if(PkgState[p->ID].Flags & Flag::Auto) - std::clog << "AutoDep: " << p.FullName() << std::endl; - - bool const follow_recommends = MarkFollowsRecommends(); - bool const follow_suggests = MarkFollowsSuggests(); - - // do the mark part, this is the core bit of the algorithm - for (PkgIterator P = PkgBegin(); !P.end(); ++P) - { - if (PkgState[P->ID].Marked || IsPkgInBoringState(P, PkgState)) - continue; - - const char *reason = nullptr; - - if ((PkgState[P->ID].Flags & Flag::Auto) == 0) - reason = "Manual-Installed"; - else if (P->Flags & Flag::Essential) - reason = "Essential"; - else if (P->Flags & Flag::Important) - reason = "Important"; - else if (P->CurrentVer != 0 && P.CurrentVer()->Priority == pkgCache::State::Required) - reason = "Required"; - else if (userFunc.InRootSet(P)) - reason = "Blacklisted [APT::NeverAutoRemove]"; - else if (not IsModeChangeOk(*this, ModeGarbage, P, 0, false, DebugMarker)) - reason = "Hold"; - else - continue; - - if (PkgState[P->ID].Install()) - MarkPackage(P, PkgState[P->ID].InstVerIter(*this), - follow_recommends, follow_suggests, reason); - else - MarkPackage(P, P.CurrentVer(), - follow_recommends, follow_suggests, reason); - } - d->fullyExplored.clear(); - return true; } /*}}}*/ // MarkPackage - mark a single package in Mark-and-Sweep /*{{{*/ -void pkgDepCache::MarkPackage(const pkgCache::PkgIterator &Pkg, - const pkgCache::VerIterator &Ver, - bool const &follow_recommends, - bool const &follow_suggests, - const char *reason) +static void MarkPackage(pkgCache::PkgIterator const &Pkg, + pkgCache::VerIterator const &Ver, + bool const follow_recommends, + bool const follow_suggests, + bool const debug_autoremove, + std::string_view const reason, + pkgCache &Cache, + pkgDepCache &DepCache, + pkgDepCache::StateCache *const PkgState, + std::vector &fullyExplored, + std::unique_ptr &IsAVersionedKernelPackage, + std::unique_ptr &IsProtectedKernelPackage) { - if (Ver.end() || (d->fullyExplored[Pkg->ID] && PkgState[Pkg->ID].Marked)) + if (Ver.end() || (fullyExplored[Pkg->ID] && PkgState[Pkg->ID].Marked)) return; if (IsPkgInBoringState(Pkg, PkgState)) { - d->fullyExplored[Pkg->ID] = true; + fullyExplored[Pkg->ID] = true; return; } PkgState[Pkg->ID].Marked = true; - bool const debug_autoremove = _config->FindB("Debug::pkgAutoRemove", false); if(debug_autoremove) std::clog << "Marking: " << Pkg.FullName() << " " << Ver.VerStr() << " (" << reason << ")" << std::endl; @@ -2315,13 +2263,13 @@ void pkgDepCache::MarkPackage(const pkgCache::PkgIterator &Pkg, for (auto D = Ver.DependsList(); not D.end(); ++D) { auto const T = D.TargetPkg(); - if (T.end() || d->fullyExplored[T->ID]) + if (T.end() || fullyExplored[T->ID]) continue; - if (D->Type != Dep::Depends && - D->Type != Dep::PreDepends && - (follow_recommends == false || D->Type != Dep::Recommends) && - (follow_suggests == false || D->Type != Dep::Suggests)) + if (D->Type != pkgCache::Dep::Depends && + D->Type != pkgCache::Dep::PreDepends && + (not follow_recommends || D->Type != pkgCache::Dep::Recommends) && + (not follow_suggests || D->Type != pkgCache::Dep::Suggests)) continue; bool unsatisfied_choice = false; @@ -2329,7 +2277,7 @@ void pkgDepCache::MarkPackage(const pkgCache::PkgIterator &Pkg, // collect real part if (not IsPkgInBoringState(T, PkgState)) { - auto const TV = (PkgState[T->ID].Install()) ? PkgState[T->ID].InstVerIter(*this) : T.CurrentVer(); + auto const TV = (PkgState[T->ID].Install()) ? PkgState[T->ID].InstVerIter(DepCache) : T.CurrentVer(); if (likely(not TV.end())) { if (not D.IsSatisfied(TV)) @@ -2349,7 +2297,7 @@ void pkgDepCache::MarkPackage(const pkgCache::PkgIterator &Pkg, // we want to ignore provides from uninteresting versions auto const PV = (PkgState[PP->ID].Install()) ? - PkgState[PP->ID].InstVerIter(*this) : PP.CurrentVer(); + PkgState[PP->ID].InstVerIter(DepCache) : PP.CurrentVer(); if (unlikely(PV.end()) || PV != Prv.OwnerVer()) continue; @@ -2366,8 +2314,8 @@ void pkgDepCache::MarkPackage(const pkgCache::PkgIterator &Pkg, // if the provider is a versioned kernel package mark them only for protected kernels if (providers.second.size() == 1) continue; - if (not d->IsAVersionedKernelPackage) - d->IsAVersionedKernelPackage = [&]() -> std::unique_ptr { + if (not IsAVersionedKernelPackage) + IsAVersionedKernelPackage = [&]() -> std::unique_ptr { auto const patterns = _config->FindVector("APT::VersionedKernelPackages"); if (patterns.empty()) return std::make_unique(); @@ -2377,35 +2325,92 @@ void pkgDepCache::MarkPackage(const pkgCache::PkgIterator &Pkg, regex << patterns.back() << "-.*$"; return std::make_unique(regex.str()); }(); - if (not std::all_of(providers.second.begin(), providers.second.end(), [&](auto const &Prv) { return (*d->IsAVersionedKernelPackage)(Prv.ParentPkg()); })) + if (not std::all_of(providers.second.begin(), providers.second.end(), [&](auto const &Prv) { return (*IsAVersionedKernelPackage)(Prv.ParentPkg()); })) continue; // … if there is at least one for protected kernels installed - if (not d->IsProtectedKernelPackage) - d->IsProtectedKernelPackage = APT::KernelAutoRemoveHelper::GetProtectedKernelsFilter(Cache); - if (not std::any_of(providers.second.begin(), providers.second.end(), [&](auto const &Prv) { return (*d->IsProtectedKernelPackage)(Prv.ParentPkg()); })) + if (not IsProtectedKernelPackage) + IsProtectedKernelPackage = APT::KernelAutoRemoveHelper::GetProtectedKernelsFilter(&Cache); + if (not std::any_of(providers.second.begin(), providers.second.end(), [&](auto const &Prv) { return (*IsProtectedKernelPackage)(Prv.ParentPkg()); })) continue; providers.second.erase(std::remove_if(providers.second.begin(), providers.second.end(), - [&](auto const &Prv) { return not((*d->IsProtectedKernelPackage)(Prv.ParentPkg())); }), + [&](auto const &Prv) { return not((*IsProtectedKernelPackage)(Prv.ParentPkg())); }), providers.second.end()); } if (not unsatisfied_choice) - d->fullyExplored[T->ID] = true; + fullyExplored[T->ID] = true; for (auto const &providers : providers_by_source) { for (auto const &PV : providers.second) { auto const PP = PV.ParentPkg(); if (debug_autoremove) - std::clog << "Following dep: " << APT::PrettyDep(this, D) + std::clog << "Following dep: " << APT::PrettyDep(&DepCache, D) << ", provided by " << PP.FullName() << " " << PV.VerStr() << " (" << providers_by_source.size() << "/" << providers.second.size() << ")\n"; - MarkPackage(PP, PV, follow_recommends, follow_suggests, "Dependency"); + MarkPackage(PP, PV, follow_recommends, follow_suggests, debug_autoremove, + "Dependency", Cache, DepCache, PkgState, fullyExplored, + IsAVersionedKernelPackage, IsProtectedKernelPackage); } } } } /*}}}*/ +// pkgDepCache::MarkRequired - the main mark algorithm /*{{{*/ +bool pkgDepCache::MarkRequired(InRootSetFunc &userFunc) +{ + if (_config->Find("APT::Solver", "internal") != "internal") + return true; + + // init the states + auto const PackagesCount = Head().PackageCount; + for(auto i = decltype(PackagesCount){0}; i < PackagesCount; ++i) + { + PkgState[i].Marked = false; + PkgState[i].Garbage = false; + } + std::vector fullyExplored(PackagesCount, false); + + bool const debug_autoremove = _config->FindB("Debug::pkgAutoRemove", false); + if (debug_autoremove) + for(PkgIterator p = PkgBegin(); !p.end(); ++p) + if(PkgState[p->ID].Flags & Flag::Auto) + std::clog << "AutoDep: " << p.FullName() << std::endl; + + bool const follow_recommends = MarkFollowsRecommends(); + bool const follow_suggests = MarkFollowsSuggests(); + + // do the mark part, this is the core bit of the algorithm + for (PkgIterator P = PkgBegin(); !P.end(); ++P) + { + if (PkgState[P->ID].Marked || IsPkgInBoringState(P, PkgState)) + continue; + + std::string_view reason; + if ((PkgState[P->ID].Flags & Flag::Auto) == 0) + reason = "Manual-Installed"; + else if (P->Flags & Flag::Essential) + reason = "Essential"; + else if (P->Flags & Flag::Important) + reason = "Important"; + else if (P->CurrentVer != 0 && P.CurrentVer()->Priority == pkgCache::State::Required) + reason = "Required"; + else if (userFunc.InRootSet(P)) + reason = "Blacklisted [APT::NeverAutoRemove]"; + else if (not IsModeChangeOk(*this, ModeGarbage, P, 0, false, DebugMarker)) + reason = "Hold"; + else + continue; + + pkgCache::VerIterator const PV = (PkgState[P->ID].Install()) ? PkgState[P->ID].InstVerIter(*this) : P.CurrentVer(); + MarkPackage(P, PV, follow_recommends, follow_suggests, debug_autoremove, + reason, *Cache, *this, PkgState, fullyExplored, + d->IsAVersionedKernelPackage, d->IsProtectedKernelPackage); + return false; + } + return true; +} + /*}}}*/ bool pkgDepCache::Sweep() /*{{{*/ { bool debug_autoremove = _config->FindB("Debug::pkgAutoRemove",false); -- cgit v1.2.3-70-g09d2