/*
- * Copyright (c) 2007-2009, Novell Inc.
+ * Copyright (c) 2007-2017, SUSE Inc.
*
* This program is licensed under the BSD license, read LICENSE.BSD
* for further information
#define RULES_BLOCK 63
static void addpkgruleinfo(Solver *solv, Id p, Id p2, Id d, int type, Id dep);
-static void solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded);
-
-/*-------------------------------------------------------------------
- * Check if dependency is possible
- *
- * mirrors solver_dep_fulfilled but uses map m instead of the decisionmap.
- * used in solver_addpkgrulesforweak and solver_createcleandepsmap.
- */
-
-static inline int
-dep_possible(Solver *solv, Id dep, Map *m)
-{
- Pool *pool = solv->pool;
- Id p, pp;
-
- if (ISRELDEP(dep))
- {
- Reldep *rd = GETRELDEP(pool, dep);
- if (rd->flags >= 8)
- {
- if (rd->flags == REL_COND || rd->flags == REL_UNLESS)
- return 1;
- if (rd->flags == REL_AND)
- {
- if (!dep_possible(solv, rd->name, m))
- return 0;
- return dep_possible(solv, rd->evr, m);
- }
- if (rd->flags == REL_OR)
- {
- if (dep_possible(solv, rd->name, m))
- return 1;
- return dep_possible(solv, rd->evr, m);
- }
- if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_SPLITPROVIDES)
- return solver_splitprovides(solv, rd->evr, m);
- }
- }
- FOR_PROVIDES(p, pp, dep)
- {
- if (MAPTST(m, p))
- return 1;
- }
- return 0;
-}
static inline int
is_otherproviders_dep(Pool *pool, Id dep)
/* find possible supplements */
supp = s->repo->idarraydata + s->supplements;
while ((sup = *supp++) != 0)
- if (dep_possible(solv, sup, m))
+ if (solver_dep_possible(solv, sup, m))
break;
}
{
supp = s->repo->idarraydata + s->enhances;
while ((sup = *supp++) != 0)
- if (dep_possible(solv, sup, m))
+ if (solver_dep_possible(solv, sup, m))
break;
}
/* if nothing found, goto next solvables */
}
-static Id
-finddistupgradepackages(Solver *solv, Solvable *s, Queue *qs)
-{
- Pool *pool = solv->pool;
- int i, j;
-
- policy_findupdatepackages(solv, s, qs, 2);
- if (qs->count)
- {
- /* remove installed packages we can't keep */
- for (i = j = 0; i < qs->count; i++)
- {
- Solvable *ns = pool->solvables + qs->elements[i];
- if (ns->repo == pool->installed && !dup_maykeepinstalled(solv, ns))
- continue;
- qs->elements[j++] = qs->elements[i];
- }
- queue_truncate(qs, j);
- }
- /* check if it is ok to keep the installed package */
- if (dup_maykeepinstalled(solv, s))
- return s - pool->solvables;
- /* nope, it must be some other package */
- return -SYSTEMSOLVABLE;
-}
-
-#if 0
-/* add packages from the dup repositories to the update candidates
- * this isn't needed for the global dup mode as all packages are
- * from dup repos in that case */
-static void
-addduppackages(Solver *solv, Solvable *s, Queue *qs)
-{
- Queue dupqs;
- Id p, dupqsbuf[64];
- int i;
- int oldnoupdateprovide = solv->noupdateprovide;
-
- queue_init_buffer(&dupqs, dupqsbuf, sizeof(dupqsbuf)/sizeof(*dupqsbuf));
- solv->noupdateprovide = 1;
- policy_findupdatepackages(solv, s, &dupqs, 2);
- solv->noupdateprovide = oldnoupdateprovide;
- for (i = 0; i < dupqs.count; i++)
- {
- p = dupqs.elements[i];
- if (MAPTST(&solv->dupmap, p))
- queue_pushunique(qs, p);
- }
- queue_free(&dupqs);
-}
-#endif
-
/* stash away the original updaters for multiversion packages. We do this so that
* we can update the package later */
static inline void
queue_init_buffer(&qs, qsbuf, sizeof(qsbuf)/sizeof(*qsbuf));
p = s - pool->solvables;
policy_findupdatepackages(solv, s, &qs, 1);
- if (solv->dupmap_all || (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p)))
+ if (solv->dupinvolvedmap_all || (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p)))
{
if (!dup_maykeepinstalled(solv, s))
{
Id p, d;
Queue qs;
Id qsbuf[64];
- int isorphaned = 0;
Rule *r;
+ int dupinvolved = 0;
p = s - pool->solvables;
/* Orphan detection. We cheat by looking at the feature rule, which
return;
}
- queue_init_buffer(&qs, qsbuf, sizeof(qsbuf)/sizeof(*qsbuf));
/* find update candidates for 's' */
- if (solv->dupmap_all || (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p)))
- p = finddistupgradepackages(solv, s, &qs);
- else
- policy_findupdatepackages(solv, s, &qs, 0);
+ queue_init_buffer(&qs, qsbuf, sizeof(qsbuf)/sizeof(*qsbuf));
+ dupinvolved = solv->dupinvolvedmap_all || (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p));
+ policy_findupdatepackages(solv, s, &qs, dupinvolved ? 2 : 0);
if (qs.count && solv->multiversion.size)
{
}
qs.elements[j++] = qs.elements[i];
}
- if (j < qs.count) /* filtered at least one package? */
+
+ if (j == 0 && dupinvolved && !dup_maykeepinstalled(solv, s))
{
- if (j == 0 && p == -SYSTEMSOLVABLE)
+ /* this is a multiversion orphan */
+ queue_push(&solv->orphaned, p);
+ set_specialupdaters(solv, s, d);
+ if (solv->keep_orphans && !(solv->droporphanedmap_all || (solv->droporphanedmap.size && MAPTST(&solv->droporphanedmap, p - solv->installed->start))))
{
- /* this is a multiversion orphan */
- queue_push(&solv->orphaned, s - pool->solvables);
- set_specialupdaters(solv, s, d);
- if (solv->keep_orphans && !(solv->droporphanedmap_all || (solv->droporphanedmap.size && MAPTST(&solv->droporphanedmap, s - pool->solvables - solv->installed->start))))
- {
- /* we need to keep the orphan */
- queue_free(&qs);
- solver_addrule(solv, s - pool->solvables, 0, 0);
- return;
- }
- /* we can drop it as long as we update */
- isorphaned = 1;
- j = qs.count; /* force the update */
+ /* we need to keep the orphan */
+ queue_free(&qs);
+ solver_addrule(solv, p, 0, 0);
+ return;
}
- else if (d && (solv->updatemap_all || (solv->updatemap.size && MAPTST(&solv->updatemap, s - pool->solvables - solv->installed->start))))
+ /* we can drop it as long as we update */
+ j = qs.count;
+ }
+
+ if (j < qs.count) /* filtered at least one package? */
+ {
+ if (d && (solv->updatemap_all || (solv->updatemap.size && MAPTST(&solv->updatemap, p - solv->installed->start))))
{
/* non-orphan multiversion package, set special updaters if we want an update */
set_specialupdaters(solv, s, d);
}
qs.count = j;
}
- else if (p != -SYSTEMSOLVABLE)
+ else
{
/* could fallthrough, but then we would do pool_queuetowhatprovides twice */
queue_free(&qs);
- solver_addrule(solv, s - pool->solvables, 0, d); /* allow update of s */
+ solver_addrule(solv, p, 0, d); /* allow update of s */
return;
}
}
}
- if (!isorphaned && p == -SYSTEMSOLVABLE && qs.count && solv->dupmap.size)
- p = s - pool->solvables; /* let the dup rules sort it out */
- if (qs.count && p == -SYSTEMSOLVABLE)
- p = queue_shift(&qs);
if (qs.count > 1)
{
d = pool_queuetowhatprovides(pool, &qs);
a = (a <= pool->lastarch) ? pool->id2arch[a] : 0;
if (a != 1 && installed && ps->repo == installed)
{
- if (!solv->dupmap_all && !(solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p)))
- queue_pushunique(&allowedarchs, ps->arch); /* also ok to keep this architecture */
- continue; /* ignore installed solvables when calculating the best arch */
+ if (solv->dupinvolvedmap_all || (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p)))
+ continue;
+ queue_pushunique(&allowedarchs, ps->arch); /* also ok to keep this architecture */
+ continue; /* but ignore installed solvables when calculating the best arch */
}
if (a && a != 1 && (!bestarch || a < bestarch))
{
ps = pool->solvables + p;
if (ps->name != s->name || ps->repo != installed || !MAPTST(addedmap, p))
continue;
- if (solv->dupmap_all || (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p)))
+ if (solv->dupinvolvedmap_all || (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p)))
continue;
a = ps->arch;
a = (a <= pool->lastarch) ? pool->id2arch[a] : 0;
***/
static inline void
-add_cleandeps_package(Solver *solv, Id p)
+add_cleandeps_updatepkg(Solver *solv, Id p)
{
if (!solv->cleandeps_updatepkgs)
{
Repo *installed = solv->installed;
Id pi, pip, obs, *obsp;
+ if (!solv->dupinvolvedmap.size)
+ map_grow(&solv->dupinvolvedmap, pool->nsolvables);
+
MAPSET(&solv->dupinvolvedmap, p);
if (targeted)
MAPSET(&solv->dupmap, p);
if (pool->solvables[pi2].repo != installed)
MAPSET(&solv->dupinvolvedmap, pi2);
}
- if (ps->repo == installed && (how & SOLVER_FORCEBEST) != 0)
+ if (ps->repo == installed && (how & SOLVER_FORCEBEST) != 0 && !solv->bestupdatemap_all)
{
if (!solv->bestupdatemap.size)
map_grow(&solv->bestupdatemap, installed->end - installed->start);
MAPSET(&solv->bestupdatemap, pi - installed->start);
}
if (ps->repo == installed && (how & SOLVER_CLEANDEPS) != 0)
- add_cleandeps_package(solv, pi);
+ add_cleandeps_updatepkg(solv, pi);
if (!targeted && ps->repo != installed)
MAPSET(&solv->dupmap, pi);
}
if (pool->solvables[pi2].repo != installed)
MAPSET(&solv->dupinvolvedmap, pi2);
}
- if (ps->repo == installed && (how & SOLVER_FORCEBEST) != 0)
+ if (ps->repo == installed && (how & SOLVER_FORCEBEST) != 0 && !solv->bestupdatemap_all)
{
if (!solv->bestupdatemap.size)
map_grow(&solv->bestupdatemap, installed->end - installed->start);
MAPSET(&solv->bestupdatemap, pi - installed->start);
}
if (ps->repo == installed && (how & SOLVER_CLEANDEPS) != 0)
- add_cleandeps_package(solv, pi);
+ add_cleandeps_updatepkg(solv, pi);
}
}
}
}
+/* create the two dupmaps:
+ * - dupmap: packages in that map are good to install/keep
+ * - dupinvolvedmap: packages are subject to dup mode
+ */
void
solver_createdupmaps(Solver *solv)
{
int i, targeted;
map_init(&solv->dupmap, pool->nsolvables);
- map_init(&solv->dupinvolvedmap, pool->nsolvables);
+ solv->dupinvolvedmap_all = 0;
+ map_init(&solv->dupinvolvedmap, 0);
for (i = 0; i < job->count; i += 2)
{
how = job->elements[i];
}
else if (select == SOLVER_SOLVABLE_ALL)
{
+ solv->dupinvolvedmap_all = 1;
FOR_POOL_SOLVABLES(p)
{
- MAPSET(&solv->dupinvolvedmap, p);
- if (installed && pool->solvables[p].repo != installed)
- MAPSET(&solv->dupmap, p);
+ Solvable *s = pool->solvables + p;
+ if (!s->repo || s->repo == installed)
+ continue;
+ if (!pool_installable(pool, s))
+ continue;
+ MAPSET(&solv->dupmap, p);
+ }
+ if ((how & SOLVER_FORCEBEST) != 0)
+ solv->bestupdatemap_all = 1;
+ if ((how & SOLVER_CLEANDEPS) != 0 && installed)
+ {
+ FOR_REPO_SOLVABLES(installed, p, s)
+ add_cleandeps_updatepkg(solv, p);
}
}
else
break;
}
}
- MAPCLR(&solv->dupinvolvedmap, SYSTEMSOLVABLE);
+ if (solv->dupinvolvedmap.size)
+ MAPCLR(&solv->dupinvolvedmap, SYSTEMSOLVABLE);
}
void
Rule *r;
solv->duprules = solv->nrules;
+ if (solv->dupinvolvedmap_all)
+ solv->updatemap_all = 1;
for (i = 1; i < pool->nsolvables; i++)
{
if (i == SYSTEMSOLVABLE || !MAPTST(addedmap, i))
first = 0;
if (first)
break;
- if (!MAPTST(&solv->dupinvolvedmap, p))
+ if (!solv->dupinvolvedmap_all && !MAPTST(&solv->dupinvolvedmap, p))
continue;
if (installed && ps->repo == installed)
{
- if (!solv->updatemap.size)
- map_grow(&solv->updatemap, installed->end - installed->start);
- MAPSET(&solv->updatemap, p - installed->start);
+ if (!solv->updatemap_all)
+ {
+ if (!solv->updatemap.size)
+ map_grow(&solv->updatemap, installed->end - installed->start);
+ MAPSET(&solv->updatemap, p - installed->start);
+ }
if (!MAPTST(&solv->dupmap, p))
{
Id ip, ipp;
}
if (ip)
{
- /* ok, found a good one. we may keep this package. */
+ /* ok, identical to a good one. we may keep this package. */
MAPSET(&solv->dupmap, p); /* for best rules processing */
continue;
}
+ /* check if it's orphaned. If yes, we may keep it */
r = solv->rules + solv->updaterules + (p - installed->start);
if (!r->p)
- r = solv->rules + solv->featurerules + (p - installed->start);
- if (r->p && solv->specialupdaters && solv->specialupdaters[p - installed->start])
+ r = solv->rules + solv->featurerules + (p - installed->start);
+ if (!r->p)
+ {
+ /* no update/feature rule, this is an orphan */
+ MAPSET(&solv->dupmap, p); /* for best rules processing */
+ continue;
+ }
+ if (solv->specialupdaters && solv->specialupdaters[p - installed->start])
{
/* this is a multiversion orphan, we're good if an update is installed */
solver_addrule(solv, -p, 0, solv->specialupdaters[p - installed->start]);
continue;
}
- if (!r->p || (r->p == p && !r->d && !r->w2))
+ if (r->p == p && !r->d && !r->w2)
{
- /* this is an orphan */
- MAPSET(&solv->dupmap, p); /* for best rules processing */
- continue;
+ r = solv->rules + solv->featurerules + (p - installed->start);
+ if (!r->p || (!r->d && !r->w2))
+ {
+ /* this is an orphan */
+ MAPSET(&solv->dupmap, p); /* for best rules processing */
+ continue;
+ }
}
solver_addrule(solv, -p, 0, 0); /* no match, sorry */
}
#define DISABLE_INFARCH 2
#define DISABLE_DUP 3
-/*
- * add all installed packages that package p obsoletes to Queue q.
- * Package p is not installed. Also, we know that if
- * solv->keepexplicitobsoletes is not set, p is not in the multiversion map.
- * Entries may get added multiple times.
- */
-static void
-add_obsoletes(Solver *solv, Id p, Queue *q)
-{
- Pool *pool = solv->pool;
- Repo *installed = solv->installed;
- Id p2, pp2;
- Solvable *s = pool->solvables + p;
- Id obs, *obsp;
- Id lastp2 = 0;
-
- if (!solv->keepexplicitobsoletes || !(solv->multiversion.size && MAPTST(&solv->multiversion, p)))
- {
- FOR_PROVIDES(p2, pp2, s->name)
- {
- Solvable *ps = pool->solvables + p2;
- if (ps->repo != installed)
- continue;
- if (!pool->implicitobsoleteusesprovides && ps->name != s->name)
- continue;
- if (pool->implicitobsoleteusescolors && !pool_colormatch(pool, s, ps))
- continue;
- queue_push(q, p2);
- lastp2 = p2;
- }
- }
- if (!s->obsoletes)
- return;
- obsp = s->repo->idarraydata + s->obsoletes;
- while ((obs = *obsp++) != 0)
- FOR_PROVIDES(p2, pp2, obs)
- {
- Solvable *ps = pool->solvables + p2;
- if (ps->repo != installed)
- continue;
- if (!pool->obsoleteusesprovides && !pool_match_nevr(pool, ps, obs))
- continue;
- if (pool->obsoleteusescolors && !pool_colormatch(pool, s, ps))
- continue;
- if (p2 == lastp2)
- continue;
- queue_push(q, p2);
- lastp2 = p2;
- }
-}
-
-/*
- * Call add_obsoletes and intersect the result with the
- * elements in Queue q starting at qstart.
- * Assumes that it's the first call if qstart == q->count.
- * May use auxillary map m for the intersection process, all
- * elements of q starting at qstart must have their bit cleared.
- * (This is also true after the function returns.)
- */
-static void
-intersect_obsoletes(Solver *solv, Id p, Queue *q, int qstart, Map *m)
-{
- int i, j;
- int qcount = q->count;
-
- add_obsoletes(solv, p, q);
- if (qcount == qstart)
- return; /* first call */
- if (qcount == q->count)
- j = qstart;
- else if (qcount == qstart + 1)
- {
- /* easy if there's just one element */
- j = qstart;
- for (i = qcount; i < q->count; i++)
- if (q->elements[i] == q->elements[qstart])
- {
- j++; /* keep the element */
- break;
- }
- }
- else if (!m->size && q->count - qstart <= 8)
- {
- /* faster than a map most of the time */
- int k;
- for (i = j = qstart; i < qcount; i++)
- {
- Id ip = q->elements[i];
- for (k = qcount; k < q->count; k++)
- if (q->elements[k] == ip)
- {
- q->elements[j++] = ip;
- break;
- }
- }
- }
- else
- {
- /* for the really pathologic cases we use the map */
- Repo *installed = solv->installed;
- if (!m->size)
- map_init(m, installed->end - installed->start);
- for (i = qcount; i < q->count; i++)
- MAPSET(m, q->elements[i] - installed->start);
- for (i = j = qstart; i < qcount; i++)
- if (MAPTST(m, q->elements[i] - installed->start))
- {
- MAPCLR(m, q->elements[i] - installed->start);
- q->elements[j++] = q->elements[i];
- }
- }
- queue_truncate(q, j);
-}
-
static void
jobtodisablelist(Solver *solv, Id how, Id what, Queue *q)
{
return;
/* now the hard part: disable some update rules */
- /* first check if we have multiversion or installed packages in the job */
- i = j = 0;
+ /* first check if we have installed or multiversion packages in the job */
FOR_JOB_SELECT(p, pp, select, what)
{
if (pool->solvables[p].repo == installed)
- j = p;
- else if (solv->multiversion.size && MAPTST(&solv->multiversion, p) && !solv->keepexplicitobsoletes)
return;
- i++;
- }
- if (j) /* have installed packages */
- {
- /* this is for dupmap_all jobs, it can go away if we create
- * duprules for them */
- if (i == 1 && (set & SOLVER_SETREPO) != 0)
- queue_push2(q, DISABLE_UPDATE, j);
- return;
+ if (solv->multiversion.size && MAPTST(&solv->multiversion, p) && !solv->keepexplicitobsoletes)
+ return;
}
-
omap.size = 0;
qstart = q->count;
FOR_JOB_SELECT(p, pp, select, what)
{
- intersect_obsoletes(solv, p, q, qstart, &omap);
+ solver_intersect_obsoleted(solv, p, q, qstart, &omap);
if (q->count == qstart)
break;
}
int i, oldcnt;
solv->bestrules = solv->nrules;
- if (!installed)
- {
- solv->bestrules_end = solv->nrules;
- return;
- }
queue_init(&q);
queue_init(&q2);
queue_init(&r2pkg);
}
}
- if (solv->bestupdatemap_all || solv->bestupdatemap.size)
+ if (installed && (solv->bestupdatemap_all || solv->bestupdatemap.size))
{
Map m;
POOL_DEBUG(SOLV_DEBUG_STATS, "yumobs rule creation took %d ms\n", solv_timems(now));
}
-#undef CLEANDEPSDEBUG
-
-/*
- * This functions collects all packages that are looked at
- * when a dependency is checked. We need it to "pin" installed
- * packages when removing a supplemented package in createcleandepsmap.
- * Here's an not uncommon example:
- * A contains "Supplements: packageand(B, C)"
- * B contains "Requires: A"
- * Now if we remove C, the supplements is no longer true,
- * thus we also remove A. Without the dep_pkgcheck function, we
- * would now also remove B, but this is wrong, as adding back
- * C doesn't make the supplements true again. Thus we "pin" B
- * when we remove A.
- * There's probably a better way to do this, but I haven't come
- * up with it yet ;)
- */
-static inline void
-dep_pkgcheck(Solver *solv, Id dep, Map *m, Queue *q)
-{
- Pool *pool = solv->pool;
- Id p, pp;
-
- if (ISRELDEP(dep))
- {
- Reldep *rd = GETRELDEP(pool, dep);
- if (rd->flags >= 8)
- {
- if (rd->flags == REL_AND)
- {
- dep_pkgcheck(solv, rd->name, m, q);
- dep_pkgcheck(solv, rd->evr, m, q);
- return;
- }
- if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_SPLITPROVIDES)
- return;
- }
- }
- FOR_PROVIDES(p, pp, dep)
- if (!m || MAPTST(m, p))
- queue_push(q, p);
-}
-
-static int
-check_xsupp(Solver *solv, Queue *depq, Id dep)
-{
- Pool *pool = solv->pool;
- Id p, pp;
-
- if (ISRELDEP(dep))
- {
- Reldep *rd = GETRELDEP(pool, dep);
- if (rd->flags >= 8)
- {
- if (rd->flags == REL_AND)
- {
- if (!check_xsupp(solv, depq, rd->name))
- return 0;
- return check_xsupp(solv, depq, rd->evr);
- }
- if (rd->flags == REL_OR)
- {
- if (check_xsupp(solv, depq, rd->name))
- return 1;
- return check_xsupp(solv, depq, rd->evr);
- }
- if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_SPLITPROVIDES)
-#if 0
- return solver_splitprovides(solv, rd->evr);
-#else
- return 0;
-#endif
- }
- if (depq && rd->flags == REL_NAMESPACE)
- {
- int i;
- for (i = 0; i < depq->count; i++)
- if (depq->elements[i] == dep || depq->elements[i] == rd->name)
- return 1;
- }
- }
- FOR_PROVIDES(p, pp, dep)
- if (p == SYSTEMSOLVABLE || pool->solvables[p].repo == solv->installed)
- return 1;
- return 0;
-}
-
-static inline int
-queue_contains(Queue *q, Id id)
-{
- int i;
- for (i = 0; i < q->count; i++)
- if (q->elements[i] == id)
- return 1;
- return 0;
-}
-
-#ifdef ENABLE_COMPLEX_DEPS
-static void
-complex_cleandeps_remove(Pool *pool, Id ip, Id req, Map *im, Map *installedm, Queue *iq)
-{
- int i;
- Queue dq;
- Id p;
-
- queue_init(&dq);
- i = pool_normalize_complex_dep(pool, req, &dq, CPLXDEPS_EXPAND);
- if (i == 0 || i == 1)
- {
- queue_free(&dq);
- return;
- }
- for (i = 0; i < dq.count; i++)
- {
- for (; (p = dq.elements[i]) != 0; i++)
- {
- if (p < 0)
- {
- if (!MAPTST(installedm, -p))
- break;
- continue;
- }
- if (p != SYSTEMSOLVABLE && MAPTST(im, p))
- {
-#ifdef CLEANDEPSDEBUG
- printf("%s requires/recommends %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
-#endif
- queue_push(iq, p);
- }
- }
- while (dq.elements[i])
- i++;
- }
- queue_free(&dq);
-}
-
-static void
-complex_cleandeps_addback(Pool *pool, Id ip, Id req, Map *im, Map *installedm, Queue *iq, Map *userinstalled)
-{
- int i, blk;
- Queue dq;
- Id p;
-
- queue_init(&dq);
- i = pool_normalize_complex_dep(pool, req, &dq, CPLXDEPS_EXPAND);
- if (i == 0 || i == 1)
- {
- queue_free(&dq);
- return;
- }
- for (i = 0; i < dq.count; i++)
- {
- blk = i;
- for (; (p = dq.elements[i]) != 0; i++)
- {
- if (p < 0)
- {
- if (!MAPTST(installedm, -p))
- break;
- }
- else if (p == ip)
- break;
- }
- if (!p)
- {
- for (i = blk; (p = dq.elements[i]) != 0; i++)
- {
- if (p < 0)
- continue;
- if (MAPTST(im, p))
- continue;
- if (!MAPTST(installedm, p))
- continue;
- if (p == ip || MAPTST(userinstalled, p - pool->installed->start))
- continue;
-#ifdef CLEANDEPSDEBUG
- printf("%s requires/recommends %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
-#endif
- MAPSET(im, p);
- queue_push(iq, p);
- }
- }
- while (dq.elements[i])
- i++;
- }
- queue_free(&dq);
-}
-
-#endif
-
-/*
- * Find all installed packages that are no longer
- * needed regarding the current solver job.
- *
- * The algorithm is:
- * - remove pass: remove all packages that could have
- * been dragged in by the obsoleted packages.
- * i.e. if package A is obsolete and contains "Requires: B",
- * also remove B, as installing A will have pulled in B.
- * after this pass, we have a set of still installed packages
- * with broken dependencies.
- * - add back pass:
- * now add back all packages that the still installed packages
- * require.
- *
- * The cleandeps packages are the packages removed in the first
- * pass and not added back in the second pass.
- *
- * If we search for unneeded packages (unneeded is true), we
- * simply remove all packages except the userinstalled ones in
- * the first pass.
- */
-static void
-solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
-{
- Pool *pool = solv->pool;
- Repo *installed = solv->installed;
- Queue *job = &solv->job;
- Map userinstalled;
- Map im;
- Map installedm;
- Rule *r;
- Id rid, how, what, select;
- Id p, pp, ip, jp;
- Id req, *reqp, sup, *supp;
- Solvable *s;
- Queue iq, iqcopy, xsuppq;
- int i;
-
- map_empty(cleandepsmap);
- if (!installed || installed->end == installed->start)
- return;
- map_init(&userinstalled, installed->end - installed->start);
- map_init(&im, pool->nsolvables);
- map_init(&installedm, pool->nsolvables);
- queue_init(&iq);
- queue_init(&xsuppq);
-
- for (i = 0; i < job->count; i += 2)
- {
- how = job->elements[i];
- if ((how & SOLVER_JOBMASK) == SOLVER_USERINSTALLED)
- {
- what = job->elements[i + 1];
- select = how & SOLVER_SELECTMASK;
- if (select == SOLVER_SOLVABLE_ALL || (select == SOLVER_SOLVABLE_REPO && what == installed->repoid))
- {
- FOR_REPO_SOLVABLES(installed, p, s)
- MAPSET(&userinstalled, p - installed->start);
- }
- FOR_JOB_SELECT(p, pp, select, what)
- if (pool->solvables[p].repo == installed)
- MAPSET(&userinstalled, p - installed->start);
- }
- if ((how & (SOLVER_JOBMASK | SOLVER_SELECTMASK)) == (SOLVER_ERASE | SOLVER_SOLVABLE_PROVIDES))
- {
- what = job->elements[i + 1];
- if (ISRELDEP(what))
- {
- Reldep *rd = GETRELDEP(pool, what);
- if (rd->flags != REL_NAMESPACE)
- continue;
- if (rd->evr == 0)
- {
- queue_pushunique(&iq, rd->name);
- continue;
- }
- FOR_PROVIDES(p, pp, what)
- if (p)
- break;
- if (p)
- continue;
- queue_pushunique(&iq, what);
- }
- }
- }
-
- /* have special namespace cleandeps erases */
- if (iq.count)
- {
- for (ip = installed->start; ip < installed->end; ip++)
- {
- s = pool->solvables + ip;
- if (s->repo != installed)
- continue;
- if (!s->supplements)
- continue;
- supp = s->repo->idarraydata + s->supplements;
- while ((sup = *supp++) != 0)
- if (ISRELDEP(sup) && check_xsupp(solv, &iq, sup) && !check_xsupp(solv, 0, sup))
- {
-#ifdef CLEANDEPSDEBUG
- printf("xsupp %s from %s\n", pool_dep2str(pool, sup), pool_solvid2str(pool, ip));
-#endif
- queue_pushunique(&xsuppq, sup);
- }
- }
- queue_empty(&iq);
- }
-
- /* also add visible patterns to userinstalled for openSUSE */
- if (1)
- {
- Dataiterator di;
- dataiterator_init(&di, pool, 0, 0, SOLVABLE_ISVISIBLE, 0, 0);
- while (dataiterator_step(&di))
- {
- Id *dp;
- if (di.solvid <= 0)
- continue;
- s = pool->solvables + di.solvid;
- if (!s->repo || !s->requires)
- continue;
- if (s->repo != installed && !pool_installable(pool, s))
- continue;
- if (strncmp(pool_id2str(pool, s->name), "pattern:", 8) != 0)
- continue;
- dp = s->repo->idarraydata + s->requires;
- for (dp = s->repo->idarraydata + s->requires; *dp; dp++)
- FOR_PROVIDES(p, pp, *dp)
- if (pool->solvables[p].repo == installed)
- {
- if (strncmp(pool_id2str(pool, pool->solvables[p].name), "pattern", 7) != 0)
- continue;
- MAPSET(&userinstalled, p - installed->start);
- }
- }
- dataiterator_free(&di);
- }
- if (1)
- {
- /* all products and their buddies are userinstalled */
- for (p = installed->start; p < installed->end; p++)
- {
- Solvable *s = pool->solvables + p;
- if (s->repo != installed)
- continue;
- if (!strncmp("product:", pool_id2str(pool, s->name), 8))
- {
- MAPSET(&userinstalled, p - installed->start);
-#ifdef ENABLE_LINKED_PKGS
- if (solv->instbuddy && solv->instbuddy[p - installed->start] > 1)
- {
- Id buddy = solv->instbuddy[p - installed->start];
- if (buddy >= installed->start && buddy < installed->end)
- MAPSET(&userinstalled, buddy - installed->start);
- }
-#endif
- }
- }
- }
-
- /* add all positive elements (e.g. locks) to "userinstalled" */
- for (rid = solv->jobrules; rid < solv->jobrules_end; rid++)
- {
- r = solv->rules + rid;
- if (r->d < 0)
- continue;
- i = solv->ruletojob.elements[rid - solv->jobrules];
- if ((job->elements[i] & SOLVER_CLEANDEPS) == SOLVER_CLEANDEPS)
- continue;
- FOR_RULELITERALS(p, jp, r)
- if (p > 0 && pool->solvables[p].repo == installed)
- MAPSET(&userinstalled, p - installed->start);
- }
-
- /* add all cleandeps candidates to iq */
- for (rid = solv->jobrules; rid < solv->jobrules_end; rid++)
- {
- r = solv->rules + rid;
- if (r->d < 0) /* disabled? */
- continue;
- if (r->d == 0 && r->p < 0 && r->w2 == 0) /* negative assertion (erase job)? */
- {
- p = -r->p;
- if (pool->solvables[p].repo != installed)
- continue;
- MAPCLR(&userinstalled, p - installed->start);
- if (unneeded)
- continue;
- i = solv->ruletojob.elements[rid - solv->jobrules];
- how = job->elements[i];
- if ((how & (SOLVER_JOBMASK|SOLVER_CLEANDEPS)) == (SOLVER_ERASE|SOLVER_CLEANDEPS))
- queue_push(&iq, p);
- }
- else if (r->p > 0) /* install job */
- {
- if (unneeded)
- continue;
- i = solv->ruletojob.elements[rid - solv->jobrules];
- if ((job->elements[i] & SOLVER_CLEANDEPS) == SOLVER_CLEANDEPS)
- {
- /* check if the literals all obsolete some installed package */
- Map om;
- int iqstart;
-
- /* just one installed literal */
- if (r->d == 0 && r->w2 == 0 && pool->solvables[r->p].repo == installed)
- continue;
- /* multiversion is bad */
- if (solv->multiversion.size && !solv->keepexplicitobsoletes)
- {
- FOR_RULELITERALS(p, jp, r)
- if (MAPTST(&solv->multiversion, p))
- break;
- if (p)
- continue;
- }
-
- om.size = 0;
- iqstart = iq.count;
- FOR_RULELITERALS(p, jp, r)
- {
- if (p < 0)
- {
- queue_truncate(&iq, iqstart); /* abort */
- break;
- }
- if (pool->solvables[p].repo == installed)
- {
- if (iq.count == iqstart)
- queue_push(&iq, p);
- else
- {
- for (i = iqstart; i < iq.count; i++)
- if (iq.elements[i] == p)
- break;
- queue_truncate(&iq, iqstart);
- if (i < iq.count)
- queue_push(&iq, p);
- }
- }
- else
- intersect_obsoletes(solv, p, &iq, iqstart, &om);
- if (iq.count == iqstart)
- break;
- }
- if (om.size)
- map_free(&om);
- }
- }
- }
- queue_init_clone(&iqcopy, &iq);
-
- if (!unneeded)
- {
- if (solv->cleandeps_updatepkgs)
- for (i = 0; i < solv->cleandeps_updatepkgs->count; i++)
- queue_push(&iq, solv->cleandeps_updatepkgs->elements[i]);
- }
-
- if (unneeded)
- queue_empty(&iq); /* just in case... */
-
- /* clear userinstalled bit for the packages we really want to delete/update */
- for (i = 0; i < iq.count; i++)
- {
- p = iq.elements[i];
- if (pool->solvables[p].repo != installed)
- continue;
- MAPCLR(&userinstalled, p - installed->start);
- }
-
- for (p = installed->start; p < installed->end; p++)
- {
- if (pool->solvables[p].repo != installed)
- continue;
- MAPSET(&installedm, p);
- if (unneeded && !MAPTST(&userinstalled, p - installed->start))
- continue;
- MAPSET(&im, p);
- }
- MAPSET(&installedm, SYSTEMSOLVABLE);
- MAPSET(&im, SYSTEMSOLVABLE);
-
-#ifdef CLEANDEPSDEBUG
- printf("REMOVE PASS\n");
-#endif
-
- for (;;)
- {
- if (!iq.count)
- {
- if (unneeded)
- break;
- /* supplements pass */
- for (ip = installed->start; ip < installed->end; ip++)
- {
- if (!MAPTST(&installedm, ip))
- continue;
- s = pool->solvables + ip;
- if (!s->supplements)
- continue;
- if (!MAPTST(&im, ip))
- continue;
- if (MAPTST(&userinstalled, ip - installed->start))
- continue;
- supp = s->repo->idarraydata + s->supplements;
- while ((sup = *supp++) != 0)
- if (dep_possible(solv, sup, &im))
- break;
- if (!sup)
- {
- supp = s->repo->idarraydata + s->supplements;
- while ((sup = *supp++) != 0)
- if (dep_possible(solv, sup, &installedm) || (xsuppq.count && queue_contains(&xsuppq, sup)))
- {
- /* no longer supplemented, also erase */
- int iqcount = iq.count;
- /* pin packages, see comment above dep_pkgcheck */
- dep_pkgcheck(solv, sup, &im, &iq);
- for (i = iqcount; i < iq.count; i++)
- {
- Id pqp = iq.elements[i];
- if (pool->solvables[pqp].repo == installed)
- MAPSET(&userinstalled, pqp - installed->start);
- }
- queue_truncate(&iq, iqcount);
-#ifdef CLEANDEPSDEBUG
- printf("%s supplemented [%s]\n", pool_solvid2str(pool, ip), pool_dep2str(pool, sup));
-#endif
- queue_push(&iq, ip);
- }
- }
- }
- if (!iq.count)
- break; /* no supplementing package found, we're done */
- }
- ip = queue_shift(&iq);
- s = pool->solvables + ip;
- if (!MAPTST(&im, ip))
- continue;
- if (!MAPTST(&installedm, ip))
- continue;
- if (s->repo == installed && MAPTST(&userinstalled, ip - installed->start))
- continue;
- MAPCLR(&im, ip);
-#ifdef CLEANDEPSDEBUG
- printf("removing %s\n", pool_solvable2str(pool, s));
-#endif
- if (s->requires)
- {
- reqp = s->repo->idarraydata + s->requires;
- while ((req = *reqp++) != 0)
- {
- if (req == SOLVABLE_PREREQMARKER)
- continue;
-#ifdef ENABLE_COMPLEX_DEPS
- if (pool_is_complex_dep(pool, req))
- {
- complex_cleandeps_remove(pool, ip, req, &im, &installedm, &iq);
- continue;
- }
-#endif
- FOR_PROVIDES(p, pp, req)
- {
- if (p != SYSTEMSOLVABLE && MAPTST(&im, p))
- {
-#ifdef CLEANDEPSDEBUG
- printf("%s requires %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
-#endif
- queue_push(&iq, p);
- }
- }
- }
- }
- if (s->recommends)
- {
- reqp = s->repo->idarraydata + s->recommends;
- while ((req = *reqp++) != 0)
- {
-#ifdef ENABLE_COMPLEX_DEPS
- if (pool_is_complex_dep(pool, req))
- {
- complex_cleandeps_remove(pool, ip, req, &im, &installedm, &iq);
- continue;
- }
-#endif
- FOR_PROVIDES(p, pp, req)
- {
- if (p != SYSTEMSOLVABLE && MAPTST(&im, p))
- {
-#ifdef CLEANDEPSDEBUG
- printf("%s recommends %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
-#endif
- queue_push(&iq, p);
- }
- }
- }
- }
- }
-
- /* turn userinstalled into remove set for pruning */
- map_empty(&userinstalled);
- for (rid = solv->jobrules; rid < solv->jobrules_end; rid++)
- {
- r = solv->rules + rid;
- if (r->p >= 0 || r->d != 0 || r->w2 != 0)
- continue; /* disabled or not erase */
- p = -r->p;
- MAPCLR(&im, p);
- if (pool->solvables[p].repo == installed)
- MAPSET(&userinstalled, p - installed->start);
- }
- if (!unneeded && solv->cleandeps_updatepkgs)
- {
- for (i = 0; i < solv->cleandeps_updatepkgs->count; i++)
- {
- p = solv->cleandeps_updatepkgs->elements[i];
- if (pool->solvables[p].repo == installed)
- MAPSET(&userinstalled, p - installed->start);
- }
- }
- MAPSET(&im, SYSTEMSOLVABLE); /* in case we cleared it above */
- for (p = installed->start; p < installed->end; p++)
- if (MAPTST(&im, p))
- queue_push(&iq, p);
- for (rid = solv->jobrules; rid < solv->jobrules_end; rid++)
- {
- r = solv->rules + rid;
- if (r->d < 0)
- continue;
- FOR_RULELITERALS(p, jp, r)
- if (p > 0)
- queue_push(&iq, p);
- }
- /* also put directly addressed packages on the install queue
- * so we can mark patterns as installed */
- for (i = 0; i < job->count; i += 2)
- {
- how = job->elements[i];
- if ((how & SOLVER_JOBMASK) == SOLVER_USERINSTALLED)
- {
- what = job->elements[i + 1];
- select = how & SOLVER_SELECTMASK;
- if (select == SOLVER_SOLVABLE && pool->solvables[what].repo != installed)
- queue_push(&iq, what);
- }
- }
-
-#ifdef CLEANDEPSDEBUG
- printf("ADDBACK PASS\n");
-#endif
- for (;;)
- {
- if (!iq.count)
- {
- /* supplements pass */
- for (ip = installed->start; ip < installed->end; ip++)
- {
- if (!MAPTST(&installedm, ip))
- continue;
- if (MAPTST(&userinstalled, ip - installed->start))
- continue;
- s = pool->solvables + ip;
- if (!s->supplements)
- continue;
- if (MAPTST(&im, ip))
- continue;
- supp = s->repo->idarraydata + s->supplements;
- while ((sup = *supp++) != 0)
- if (dep_possible(solv, sup, &im))
- break;
- if (sup)
- {
-#ifdef CLEANDEPSDEBUG
- printf("%s supplemented\n", pool_solvid2str(pool, ip));
-#endif
- MAPSET(&im, ip);
- queue_push(&iq, ip);
- }
- }
- if (!iq.count)
- break;
- }
- ip = queue_shift(&iq);
- s = pool->solvables + ip;
-#ifdef CLEANDEPSDEBUG
- printf("adding back %s\n", pool_solvable2str(pool, s));
-#endif
- if (s->repo == installed && pool->implicitobsoleteusescolors)
- {
- Id a, bestarch = 0;
- FOR_PROVIDES(p, pp, s->name)
- {
- Solvable *ps = pool->solvables + p;
- if (ps->name != s->name || ps->repo == installed)
- continue;
- a = ps->arch;
- a = (a <= pool->lastarch) ? pool->id2arch[a] : 0;
- if (a && a != 1 && (!bestarch || a < bestarch))
- bestarch = a;
- }
- if (bestarch && (s->arch > pool->lastarch || pool->id2arch[s->arch] != bestarch))
- {
- FOR_PROVIDES(p, pp, s->name)
- {
- Solvable *ps = pool->solvables + p;
- if (ps->repo == installed && ps->name == s->name && ps->evr == s->evr && ps->arch != s->arch && ps->arch < pool->lastarch && pool->id2arch[ps->arch] == bestarch)
- if (!MAPTST(&im, p))
- {
-#ifdef CLEANDEPSDEBUG
- printf("%s lockstep %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
-#endif
- MAPSET(&im, p);
- queue_push(&iq, p);
- }
- }
- }
- }
- if (s->requires)
- {
- reqp = s->repo->idarraydata + s->requires;
- while ((req = *reqp++) != 0)
- {
-#ifdef ENABLE_COMPLEX_DEPS
- if (pool_is_complex_dep(pool, req))
- {
- complex_cleandeps_addback(pool, ip, req, &im, &installedm, &iq, &userinstalled);
- continue;
- }
-#endif
- FOR_PROVIDES(p, pp, req)
- if (p == ip)
- break;
- if (p)
- continue;
- FOR_PROVIDES(p, pp, req)
- {
- if (MAPTST(&im, p))
- continue;
- if (MAPTST(&installedm, p))
- {
- if (p == ip)
- continue;
- if (MAPTST(&userinstalled, p - installed->start))
- continue;
-#ifdef CLEANDEPSDEBUG
- printf("%s requires %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
-#endif
- MAPSET(&im, p);
- queue_push(&iq, p);
- }
- }
- }
- }
- if (s->recommends)
- {
- reqp = s->repo->idarraydata + s->recommends;
- while ((req = *reqp++) != 0)
- {
-#ifdef ENABLE_COMPLEX_DEPS
- if (pool_is_complex_dep(pool, req))
- {
- complex_cleandeps_addback(pool, ip, req, &im, &installedm, &iq, &userinstalled);
- continue;
- }
-#endif
- FOR_PROVIDES(p, pp, req)
- if (p == ip)
- break;
- if (p)
- continue;
- FOR_PROVIDES(p, pp, req)
- {
- if (MAPTST(&im, p))
- continue;
- if (MAPTST(&installedm, p))
- {
- if (p == ip)
- continue;
- if (MAPTST(&userinstalled, p - installed->start))
- continue;
-#ifdef CLEANDEPSDEBUG
- printf("%s recommends %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
-#endif
- MAPSET(&im, p);
- queue_push(&iq, p);
- }
- }
- }
- }
- }
-
- queue_free(&iq);
- /* make sure the updatepkgs and mistakes are not in the cleandeps map */
- if (solv->cleandeps_updatepkgs)
- for (i = 0; i < solv->cleandeps_updatepkgs->count; i++)
- MAPSET(&im, solv->cleandeps_updatepkgs->elements[i]);
- if (solv->cleandeps_mistakes)
- for (i = 0; i < solv->cleandeps_mistakes->count; i++)
- MAPSET(&im, solv->cleandeps_mistakes->elements[i]);
- /* also remove original iq packages */
- for (i = 0; i < iqcopy.count; i++)
- MAPSET(&im, iqcopy.elements[i]);
- queue_free(&iqcopy);
- for (p = installed->start; p < installed->end; p++)
- {
- if (pool->solvables[p].repo != installed)
- continue;
- if (!MAPTST(&im, p))
- MAPSET(cleandepsmap, p - installed->start);
- }
- map_free(&im);
- map_free(&installedm);
- map_free(&userinstalled);
- queue_free(&xsuppq);
-#ifdef CLEANDEPSDEBUG
- printf("=== final cleandeps map:\n");
- for (p = installed->start; p < installed->end; p++)
- if (MAPTST(cleandepsmap, p - installed->start))
- printf(" - %s\n", pool_solvid2str(pool, p));
-#endif
-}
-
-
-struct trj_data {
- Queue *edges;
- Id *low;
- Id idx;
- Id nstack;
- Id firstidx;
-};
-
-/* Tarjan's SCC algorithm, slightly modifed */
-static void
-trj_visit(struct trj_data *trj, Id node)
-{
- Id *low = trj->low;
- Queue *edges = trj->edges;
- Id nnode, myidx, stackstart;
- int i;
-
- low[node] = myidx = trj->idx++;
- low[(stackstart = trj->nstack++)] = node;
- for (i = edges->elements[node]; (nnode = edges->elements[i]) != 0; i++)
- {
- Id l = low[nnode];
- if (!l)
- {
- if (!edges->elements[edges->elements[nnode]])
- {
- trj->idx++;
- low[nnode] = -1;
- continue;
- }
- trj_visit(trj, nnode);
- l = low[nnode];
- }
- if (l < 0)
- continue;
- if (l < trj->firstidx)
- {
- int k;
- for (k = l; low[low[k]] == l; k++)
- low[low[k]] = -1;
- }
- else if (l < low[node])
- low[node] = l;
- }
- if (low[node] == myidx)
- {
- if (myidx != trj->firstidx)
- myidx = -1;
- for (i = stackstart; i < trj->nstack; i++)
- low[low[i]] = myidx;
- trj->nstack = stackstart;
- }
-}
-
-#ifdef ENABLE_COMPLEX_DEPS
-static void
-complex_unneeded(Pool *pool, Id ip, Id req, Queue *edges, Map *cleandepsmap, Queue *unneededq)
-{
- int i, j;
- Queue dq;
- Id p;
-
- queue_init(&dq);
- i = pool_normalize_complex_dep(pool, req, &dq, CPLXDEPS_EXPAND);
- if (i == 0 || i == 1)
- {
- queue_free(&dq);
- return;
- }
- for (i = 0; i < dq.count; i++)
- {
- for (; (p = dq.elements[i]) != 0; i++)
- {
- if (p < 0)
- {
- if (pool->solvables[-p].repo != pool->installed)
- break;
- continue;
- }
- if (p == ip || pool->solvables[p].repo != pool->installed || !MAPTST(cleandepsmap, p - pool->installed->start))
- continue;
- for (j = 0; j < unneededq->count; j++)
- if (p == unneededq->elements[j])
- {
- if (edges->elements[edges->count - 1] != j + 1)
- queue_push(edges, j + 1);
- break;
- }
- }
- while (dq.elements[i])
- i++;
- }
- queue_free(&dq);
-}
-#endif
-
-void
-solver_get_unneeded(Solver *solv, Queue *unneededq, int filtered)
-{
- Repo *installed = solv->installed;
- int i;
- Map cleandepsmap;
-
- queue_empty(unneededq);
- if (!installed || installed->end == installed->start)
- return;
-
- map_init(&cleandepsmap, installed->end - installed->start);
- solver_createcleandepsmap(solv, &cleandepsmap, 1);
- for (i = installed->start; i < installed->end; i++)
- if (MAPTST(&cleandepsmap, i - installed->start))
- queue_push(unneededq, i);
-
- if (filtered && unneededq->count > 1)
- {
- Pool *pool = solv->pool;
- Queue edges;
- Id *nrequires;
- Map installedm;
- int j, pass, count = unneededq->count;
- Id *low;
-
- map_init(&installedm, pool->nsolvables);
- for (i = installed->start; i < installed->end; i++)
- if (pool->solvables[i].repo == installed)
- MAPSET(&installedm, i);
-
- nrequires = solv_calloc(count, sizeof(Id));
- queue_init(&edges);
- queue_prealloc(&edges, count * 4 + 10); /* pre-size */
-
- /*
- * Go through the solvables in the nodes queue and create edges for
- * all requires/recommends/supplements between the nodes.
- * The edges are stored in the edges queue, we add 1 to the node
- * index so that nodes in the edges queue are != 0 and we can
- * terminate the edge list with 0.
- * Thus for node element 5, the edges are stored starting at
- * edges.elements[6] and are 0-terminated.
- */
- /* leave first element zero to make things easier */
- /* also add trailing zero */
- queue_insertn(&edges, 0, 1 + count + 1, 0);
-
- /* first requires and recommends */
- for (i = 0; i < count; i++)
- {
- Solvable *s = pool->solvables + unneededq->elements[i];
- int oldcount = edges.count;
- edges.elements[i + 1] = oldcount;
- for (pass = 0; pass < 2; pass++)
- {
- unsigned int off = pass == 0 ? s->requires : s->recommends;
- Id p, pp, dep, *dp;
- if (off)
- for (dp = s->repo->idarraydata + off; (dep = *dp) != 0; dp++)
- {
-#ifdef ENABLE_COMPLEX_DEPS
- if (pool_is_complex_dep(pool, dep))
- {
- complex_unneeded(pool, s - pool->solvables, dep, &edges, &cleandepsmap, unneededq);
- continue;
- }
-#endif
- FOR_PROVIDES(p, pp, dep)
- {
- Solvable *sp = pool->solvables + p;
- if (s == sp || sp->repo != installed || !MAPTST(&cleandepsmap, p - installed->start))
- continue;
- for (j = 0; j < count; j++)
- if (p == unneededq->elements[j])
- {
- if (edges.elements[edges.count - 1] != j + 1)
- queue_push(&edges, j + 1);
- }
- }
- }
- if (pass == 0)
- nrequires[i] = edges.count - oldcount;
- }
- queue_push(&edges, 0);
- }
-#if 0
- printf("requires + recommends\n");
- for (i = 0; i < count; i++)
- {
- int j;
- printf(" %s (%d requires):\n", pool_solvid2str(pool, unneededq->elements[i]), nrequires[i]);
- for (j = edges.elements[i + 1]; edges.elements[j]; j++)
- printf(" - %s\n", pool_solvid2str(pool, unneededq->elements[edges.elements[j] - 1]));
- }
-#endif
-
- /* then add supplements */
- for (i = 0; i < count; i++)
- {
- Solvable *s = pool->solvables + unneededq->elements[i];
- if (s->supplements)
- {
- Id *dp;
- int k;
- for (dp = s->repo->idarraydata + s->supplements; *dp; dp++)
- if (dep_possible(solv, *dp, &installedm))
- {
- Queue iq;
- Id iqbuf[16];
- queue_init_buffer(&iq, iqbuf, sizeof(iqbuf)/sizeof(*iqbuf));
- dep_pkgcheck(solv, *dp, 0, &iq);
- for (k = 0; k < iq.count; k++)
- {
- Id p = iq.elements[k];
- Solvable *sp = pool->solvables + p;
- if (p == unneededq->elements[i] || sp->repo != installed || !MAPTST(&cleandepsmap, p - installed->start))
- continue;
- for (j = 0; j < count; j++)
- if (p == unneededq->elements[j])
- break;
- /* now add edge from j + 1 to i + 1 */
- queue_insert(&edges, edges.elements[j + 1] + nrequires[j], i + 1);
- /* addapt following edge pointers */
- for (j = j + 2; j < count + 1; j++)
- edges.elements[j]++;
- }
- queue_free(&iq);
- }
- }
- }
-#if 0
- /* print result */
- printf("+ supplements\n");
- for (i = 0; i < count; i++)
- {
- int j;
- printf(" %s (%d requires):\n", pool_solvid2str(pool, unneededq->elements[i]), nrequires[i]);
- for (j = edges.elements[i + 1]; edges.elements[j]; j++)
- printf(" - %s\n", pool_solvid2str(pool, unneededq->elements[edges.elements[j] - 1]));
- }
-#endif
- map_free(&installedm);
-
- /* now run SCC algo two times, first with requires+recommends+supplements,
- * then again without the requires. We run it the second time to get rid
- * of packages that got dragged in via recommends/supplements */
- /*
- * low will contain the result of the SCC search.
- * it must be of at least size 2 * (count + 1) and
- * must be zero initialized.
- * The layout is:
- * 0 low low ... low stack stack ...stack 0
- * count count
- */
- low = solv_calloc(count + 1, 2 * sizeof(Id));
- for (pass = 0; pass < 2; pass++)
- {
- struct trj_data trj;
- if (pass)
- {
- memset(low, 0, (count + 1) * (2 * sizeof(Id)));
- for (i = 0; i < count; i++)
- {
- edges.elements[i + 1] += nrequires[i];
- if (!unneededq->elements[i])
- low[i + 1] = -1; /* ignore this node */
- }
- }
- trj.edges = &edges;
- trj.low = low;
- trj.idx = count + 1; /* stack starts here */
- for (i = 1; i <= count; i++)
- {
- if (low[i])
- continue;
- if (edges.elements[edges.elements[i]])
- {
- trj.firstidx = trj.nstack = trj.idx;
- trj_visit(&trj, i);
- }
- else
- {
- Id myidx = trj.idx++;
- low[i] = myidx;
- low[myidx] = i;
- }
- }
- /* prune packages */
- for (i = 0; i < count; i++)
- if (low[i + 1] <= 0)
- unneededq->elements[i] = 0;
- }
- solv_free(low);
- solv_free(nrequires);
- queue_free(&edges);
-
- /* finally remove all pruned entries from unneededq */
- for (i = j = 0; i < count; i++)
- if (unneededq->elements[i])
- unneededq->elements[j++] = unneededq->elements[i];
- queue_truncate(unneededq, j);
- }
- map_free(&cleandepsmap);
-}
-
-
void
solver_breakorphans(Solver *solv)
{
projects / platform / upstream / libsolv.git / blobdiff