X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Frules.c;h=bf98b1803b5459bfb0aaa5c29f3009f511859f6e;hb=1aac48dff40ef592968a18058bad270da65ed847;hp=331b34465793559e00fe04cc3a422bcc4c8285a2;hpb=6873aab5b6bcb3ac790bdb5ea765d879643eecf6;p=platform%2Fupstream%2Flibsolv.git diff --git a/src/rules.c b/src/rules.c index 331b344..7d57cfd 100644 --- a/src/rules.c +++ b/src/rules.c @@ -1,5 +1,5 @@ /* - * 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 @@ -18,47 +18,28 @@ #include #include "solver.h" +#include "solver_private.h" #include "bitmap.h" #include "pool.h" #include "poolarch.h" #include "util.h" +#include "evr.h" #include "policy.h" #include "solverdebug.h" +#include "linkedpkg.h" +#include "cplxdeps.h" #define RULES_BLOCK 63 -static void addrpmruleinfo(Solver *solv, Id p, Id d, int type, Id dep); -static void solver_createcleandepsmap(Solver *solv); - -/*------------------------------------------------------------------- - * Check if dependency is possible - * - * mirrors solver_dep_fulfilled but uses map m instead of the decisionmap - */ +static void addpkgruleinfo(Solver *solv, Id p, Id p2, Id d, int type, Id dep); static inline int -dep_possible(Solver *solv, Id dep, Map *m) +is_otherproviders_dep(Pool *pool, Id dep) { - Pool *pool = solv->pool; - Id p, pp; - if (ISRELDEP(dep)) { Reldep *rd = GETRELDEP(pool, dep); - 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_NAMESPACE && rd->name == NAMESPACE_SPLITPROVIDES) - return solver_splitprovides(solv, rd->evr); - if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_INSTALLED) - return solver_dep_installed(solv, rd->evr); - } - FOR_PROVIDES(p, pp, dep) - { - if (MAPTST(m, p)) + if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_OTHERPROVIDERS) return 1; } return 0; @@ -88,24 +69,27 @@ unifyrules_sortcmp(const void *ap, const void *bp, void *dp) x = a->p - b->p; if (x) - return x; /* p differs */ + return x; /* p differs */ /* identical p */ - if (a->d == 0 && b->d == 0) - return a->w2 - b->w2; /* assertion: return w2 diff */ + if (a->d == 0 && b->d == 0) /* both assertions or binary */ + return a->w2 - b->w2; - if (a->d == 0) /* a is assertion, b not */ + if (a->d == 0) /* a is assertion or binary, b not */ { x = a->w2 - pool->whatprovidesdata[b->d]; return x ? x : -1; } - if (b->d == 0) /* b is assertion, a not */ + if (b->d == 0) /* b is assertion or binary, a not */ { x = pool->whatprovidesdata[a->d] - b->w2; return x ? x : 1; } + if (a->d == b->d) + return 0; + /* compare whatprovidesdata */ ad = pool->whatprovidesdata + a->d; bd = pool->whatprovidesdata + b->d; @@ -116,7 +100,7 @@ unifyrules_sortcmp(const void *ap, const void *bp, void *dp) } int -solver_samerule(Solver *solv, Rule *r1, Rule *r2) +solver_rulecmp(Solver *solv, Rule *r1, Rule *r2) { return unifyrules_sortcmp(r1, r2, solv->pool); } @@ -135,39 +119,57 @@ solver_unifyrules(Solver *solv) int i, j; Rule *ir, *jr; - if (solv->nrules <= 1) /* nothing to unify */ + if (solv->nrules <= 2) /* nothing to unify */ return; - POOL_DEBUG(SAT_DEBUG_SCHUBI, "----- unifyrules -----\n"); + if (solv->recommendsruleq) + { + /* mis-use n2 as recommends rule marker */ + for (i = 1, ir = solv->rules + i; i < solv->nrules; i++, ir++) + ir->n2 = 0; + for (i = 0; i < solv->recommendsruleq->count; i++) + solv->rules[solv->recommendsruleq->elements[i]].n2 = 1; + } /* sort rules first */ - sat_sort(solv->rules + 1, solv->nrules - 1, sizeof(Rule), unifyrules_sortcmp, solv->pool); + solv_sort(solv->rules + 1, solv->nrules - 1, sizeof(Rule), unifyrules_sortcmp, solv->pool); - /* prune rules - * i = unpruned - * j = pruned - */ + /* prune rules */ jr = 0; for (i = j = 1, ir = solv->rules + i; i < solv->nrules; i++, ir++) { if (jr && !unifyrules_sortcmp(ir, jr, pool)) - continue; /* prune! */ - jr = solv->rules + j++; /* keep! */ + { + jr->n2 &= ir->n2; /* bitwise-and recommends marker */ + continue; /* prune! */ + } + jr = solv->rules + j++; /* keep! */ if (ir != jr) *jr = *ir; } /* reduced count from nrules to j rules */ - POOL_DEBUG(SAT_DEBUG_STATS, "pruned rules from %d to %d\n", solv->nrules, j); + POOL_DEBUG(SOLV_DEBUG_STATS, "pruned rules from %d to %d\n", solv->nrules, j); /* adapt rule buffer */ - solv->nrules = j; - solv->rules = sat_extend_resize(solv->rules, solv->nrules, sizeof(Rule), RULES_BLOCK); + solver_shrinkrules(solv, j); + + if (solv->recommendsruleq) + { + /* rebuild recommendsruleq */ + queue_empty(solv->recommendsruleq); + for (i = 1, ir = solv->rules + i; i < solv->nrules; i++, ir++) + if (ir->n2) + { + ir->n2 = 0; + queue_push(solv->recommendsruleq, i); + } + } /* * debug: log rule statistics */ - IF_POOLDEBUG (SAT_DEBUG_STATS) + IF_POOLDEBUG (SOLV_DEBUG_STATS) { int binr = 0; int lits = 0; @@ -181,15 +183,14 @@ solver_unifyrules(Solver *solv) binr++; else { - dp = solv->pool->whatprovidesdata + r->d; + dp = pool->whatprovidesdata + r->d; while (*dp++) lits++; } } - POOL_DEBUG(SAT_DEBUG_STATS, " binary: %d\n", binr); - POOL_DEBUG(SAT_DEBUG_STATS, " normal: %d, %d literals\n", solv->nrules - 1 - binr, lits); + POOL_DEBUG(SOLV_DEBUG_STATS, " binary: %d\n", binr); + POOL_DEBUG(SOLV_DEBUG_STATS, " normal: %d, %d literals\n", solv->nrules - 1 - binr, lits); } - POOL_DEBUG(SAT_DEBUG_SCHUBI, "----- unifyrules end -----\n"); } #if 0 @@ -215,170 +216,134 @@ hashrule(Solver *solv, Id p, Id d, int n) /*------------------------------------------------------------------- - * + * */ /* * add rule - * p = direct literal; always < 0 for installed rpm rules - * d, if < 0 direct literal, if > 0 offset into whatprovides, if == 0 rule is assertion (look at p only) - * * * A requires b, b provided by B1,B2,B3 => (-A|B1|B2|B3) * - * p < 0 : pkg id of A - * d > 0 : Offset in whatprovidesdata (list of providers of b) + * p < 0 : pkg id of A + * d > 0 : Offset in whatprovidesdata (list of providers of b) * * A conflicts b, b provided by B1,B2,B3 => (-A|-B1), (-A|-B2), (-A|-B3) - * p < 0 : pkg id of A - * d < 0 : Id of solvable (e.g. B1) + * p < 0 : pkg id of A + * p2 < 0 : Id of solvable (e.g. B1) * - * d == 0: unary rule, assertion => (A) or (-A) + * d == 0, p2 == 0: unary rule, assertion => (A) or (-A) * * Install: p > 0, d = 0 (A) user requested install * Remove: p < 0, d = 0 (-A) user requested remove (also: uninstallable) * Requires: p < 0, d > 0 (-A|B1|B2|...) d: * Updates: p > 0, d > 0 (A|B1|B2|...) d: - * Conflicts: p < 0, d < 0 (-A|-B) either p (conflict issuer) or d (conflict provider) (binary rule) + * Conflicts: p < 0, p2 < 0 (-A|-B) either p (conflict issuer) or d (conflict provider) (binary rule) * also used for obsoletes - * ?: p > 0, d < 0 (A|-B) - * No-op ?: p = 0, d = 0 (null) (used as policy rule placeholder) + * No-op ?: p = 0, d = 0 (null) (used as placeholder in update/feature rules) * * resulting watches: * ------------------ - * Direct assertion (no watch needed)( if d <0 ) --> d = 0, w1 = p, w2 = 0 + * Direct assertion (no watch needed) --> d = 0, w1 = p, w2 = 0 * Binary rule: p = first literal, d = 0, w2 = second literal, w1 = p * every other : w1 = p, w2 = whatprovidesdata[d]; - * Disabled rule: w1 = 0 * - * always returns a rule for non-rpm rules + * always returns a rule for non-pkg rules */ Rule * -solver_addrule(Solver *solv, Id p, Id d) +solver_addrule(Solver *solv, Id p, Id p2, Id d) { Pool *pool = solv->pool; - Rule *r = 0; - Id *dp = 0; - - int n = 0; /* number of literals in rule - 1 - 0 = direct assertion (single literal) - 1 = binary rule - >1 = - */ - - /* it often happenes that requires lead to adding the same rpm rule - * multiple times, so we prune those duplicates right away to make - * the work for unifyrules a bit easier */ + Rule *r; - if (solv->nrules /* we already have rules */ - && !solv->rpmrules_end) /* but are not done with rpm rules */ + if (d) { - r = solv->rules + solv->nrules - 1; /* get the last added rule */ - if (r->p == p && r->d == d && d != 0) /* identical and not user requested */ - return r; + assert(!p2 && d > 0); + if (!pool->whatprovidesdata[d]) + d = 0; + else if (!pool->whatprovidesdata[d + 1]) + { + p2 = pool->whatprovidesdata[d]; + d = 0; + } } - /* - * compute number of literals (n) in rule - */ - - if (d < 0) - { - /* always a binary rule */ - if (p == d) - return 0; /* ignore self conflict */ - n = 1; - } - else if (d > 0) - { - for (dp = pool->whatprovidesdata + d; *dp; dp++, n++) - if (*dp == -p) - return 0; /* rule is self-fulfilling */ - - if (n == 1) /* have single provider */ - d = dp[-1]; /* take single literal */ - } + /* now we have two cases: + * 1 or 2 literals: d = 0, p, p2 contain the literals + * 3 or more literals: d > 0, p2 == 0, d is offset into whatprovidesdata + */ - if (n == 1 && p > d && !solv->rpmrules_end) + /* it often happenes that requires lead to adding the same pkg rule + * multiple times, so we prune those duplicates right away to make + * the work for unifyrules a bit easier */ + if (!solv->pkgrules_end) /* we add pkg rules */ { - /* smallest literal first so we can find dups */ - n = p; p = d; d = n; /* p <-> d */ - n = 1; /* re-set n, was used as temp var */ + r = solv->rules + solv->lastpkgrule; + if (d) + { + Id *dp; + /* check if rule is identical */ + if (r->p == p) + { + Id *dp2; + if (r->d == d) + return r; + dp2 = pool->whatprovidesdata + r->d; + for (dp = pool->whatprovidesdata + d; *dp; dp++, dp2++) + if (*dp != *dp2) + break; + if (*dp == *dp2) + return r; + } + /* check if rule is self-fulfilling */ + for (dp = pool->whatprovidesdata + d; *dp; dp++) + if (*dp == -p) + return 0; /* rule is self-fulfilling */ + } + else + { + if (p2 && p > p2) + { + Id o = p; /* switch p1 and p2 */ + p = p2; + p2 = o; + } + if (r->p == p && !r->d && r->w2 == p2) + return r; + if (p == -p2) + return 0; /* rule is self-fulfilling */ + } + solv->lastpkgrule = solv->nrules; } - /* - * check for duplicate - */ - - /* check if the last added rule (r) is exactly the same as what we're looking for. */ - if (r && n == 1 && !r->d && r->p == p && r->w2 == d) - return r; /* binary rule */ - - /* have n-ary rule with same first literal, check other literals */ - if (r && n > 1 && r->d && r->p == p) - { - /* Rule where d is an offset in whatprovidesdata */ - Id *dp2; - if (d == r->d) - return r; - dp2 = pool->whatprovidesdata + r->d; - for (dp = pool->whatprovidesdata + d; *dp; dp++, dp2++) - if (*dp != *dp2) - break; - if (*dp == *dp2) - return r; - } - - /* - * allocate new rule - */ - - /* extend rule buffer */ - solv->rules = sat_extend(solv->rules, solv->nrules, 1, sizeof(Rule), RULES_BLOCK); + solv->rules = solv_extend(solv->rules, solv->nrules, 1, sizeof(Rule), RULES_BLOCK); r = solv->rules + solv->nrules++; /* point to rule space */ - - /* - * r = new rule - */ - r->p = p; - if (n == 0) - { - /* direct assertion, no watch needed */ - r->d = 0; - r->w1 = p; - r->w2 = 0; - } - else if (n == 1) - { - /* binary rule */ - r->d = 0; - r->w1 = p; - r->w2 = d; - } - else - { - r->d = d; - r->w1 = p; - r->w2 = pool->whatprovidesdata[d]; - } + r->d = d; + r->w1 = p; + r->w2 = d ? pool->whatprovidesdata[d] : p2; r->n1 = 0; r->n2 = 0; - - IF_POOLDEBUG (SAT_DEBUG_RULE_CREATION) + IF_POOLDEBUG (SOLV_DEBUG_RULE_CREATION) { - POOL_DEBUG(SAT_DEBUG_RULE_CREATION, " Add rule: "); - solver_printrule(solv, SAT_DEBUG_RULE_CREATION, r); + POOL_DEBUG(SOLV_DEBUG_RULE_CREATION, " Add rule: "); + solver_printrule(solv, SOLV_DEBUG_RULE_CREATION, r); } - return r; } +void +solver_shrinkrules(Solver *solv, int nrules) +{ + solv->nrules = nrules; + solv->rules = solv_extend_resize(solv->rules, solv->nrules, sizeof(Rule), RULES_BLOCK); + solv->lastpkgrule = 0; +} + /****************************************************************************** *** - *** rpm rule part: create rules representing the package dependencies + *** pkg rule part: create rules representing the package dependencies *** ***/ @@ -405,7 +370,7 @@ makemultiversionconflict(Solver *solv, Id n, Id con) s = pool->solvables + p; if (s->name != sn->name || s->arch != sn->arch) continue; - if (!MAPTST(&solv->noobsoletes, p)) + if (!MAPTST(&solv->multiversion, p)) continue; if (pool_match_nevr(pool, pool->solvables + p, con)) continue; @@ -414,58 +379,367 @@ makemultiversionconflict(Solver *solv, Id n, Id con) queue_push(&q, p); } if (q.count == 1) - return -n; /* no other package found, generate normal conflict */ - return pool_queuetowhatprovides(pool, &q); + n = 0; /* no other package found, normal conflict handling */ + else + n = pool_queuetowhatprovides(pool, &q); + queue_free(&q); + return n; } static inline void -addrpmrule(Solver *solv, Id p, Id d, int type, Id dep) +addpkgrule(Solver *solv, Id p, Id p2, Id d, int type, Id dep) { if (!solv->ruleinfoq) - solver_addrule(solv, p, d); + solver_addrule(solv, p, p2, d); + else + addpkgruleinfo(solv, p, p2, d, type, dep); +} + +#ifdef ENABLE_LINKED_PKGS + +static int +addlinks_cmp(const void *ap, const void *bp, void *dp) +{ + Pool *pool = dp; + Id a = *(Id *)ap; + Id b = *(Id *)bp; + Solvable *sa = pool->solvables + a; + Solvable *sb = pool->solvables + b; + if (sa->name != sb->name) + return sa->name - sb->name; + return sa - sb; +} + +static void +addlinks(Solver *solv, Solvable *s, Id req, Queue *qr, Id prv, Queue *qp, Map *m, Queue *workq) +{ + Pool *pool = solv->pool; + int i; + if (!qr->count) + return; + if (qp->count > 1) + solv_sort(qp->elements, qp->count, sizeof(Id), addlinks_cmp, pool); +#if 0 + printf("ADDLINKS %s\n -> %s\n", pool_solvable2str(pool, s), pool_dep2str(pool, req)); + for (i = 0; i < qr->count; i++) + printf(" - %s\n", pool_solvid2str(pool, qr->elements[i])); + printf(" <- %s\n", pool_dep2str(pool, prv)); + for (i = 0; i < qp->count; i++) + printf(" - %s\n", pool_solvid2str(pool, qp->elements[i])); +#endif + + if (qr->count == 1) + addpkgrule(solv, -(s - pool->solvables), qr->elements[0], 0, SOLVER_RULE_PKG_REQUIRES, req); else - addrpmruleinfo(solv, p, d, type, dep); + addpkgrule(solv, -(s - pool->solvables), 0, pool_queuetowhatprovides(pool, qr), SOLVER_RULE_PKG_REQUIRES, req); + if (qp->count > 1) + { + int j; + for (i = j = 0; i < qp->count; i = j) + { + Id d = pool->solvables[qp->elements[i]].name; + for (j = i + 1; j < qp->count; j++) + if (d != pool->solvables[qp->elements[j]].name) + break; + d = pool_ids2whatprovides(pool, qp->elements + i, j - i); + for (i = 0; i < qr->count; i++) + addpkgrule(solv, -qr->elements[i], 0, d, SOLVER_RULE_PKG_REQUIRES, prv); + } + } + else if (qp->count) + { + for (i = 0; i < qr->count; i++) + addpkgrule(solv, -qr->elements[i], qp->elements[0], 0, SOLVER_RULE_PKG_REQUIRES, prv); + } + if (!m) + return; /* nothing more to do if called from getpkgruleinfos() */ + for (i = 0; i < qr->count; i++) + if (!MAPTST(m, qr->elements[i])) + queue_push(workq, qr->elements[i]); + for (i = 0; i < qp->count; i++) + if (!MAPTST(m, qp->elements[i])) + queue_push(workq, qp->elements[i]); + if (solv->installed && s->repo == solv->installed) + { + Repo *installed = solv->installed; + /* record installed buddies */ + if (!solv->instbuddy) + solv->instbuddy = solv_calloc(installed->end - installed->start, sizeof(Id)); + if (qr->count == 1) + solv->instbuddy[s - pool->solvables - installed->start] = qr->elements[0]; + for (i = 0; i < qr->count; i++) + { + Id p = qr->elements[i]; + if (pool->solvables[p].repo != installed) + continue; /* huh? */ + if (qp->count > 1 || (solv->instbuddy[p - installed->start] != 0 && solv->instbuddy[p - installed->start] != s - pool->solvables)) + solv->instbuddy[p - installed->start] = 1; /* 1: ambiguous buddy */ + else + solv->instbuddy[p - installed->start] = s - pool->solvables; + } + } +} + +static void +add_package_link(Solver *solv, Solvable *s, Map *m, Queue *workq) +{ + Queue qr, qp; + Id req = 0, prv = 0; + queue_init(&qr); + queue_init(&qp); + find_package_link(solv->pool, s, &req, &qr, &prv, &qp); + if (qr.count) + addlinks(solv, s, req, &qr, prv, &qp, m, workq); + queue_free(&qr); + queue_free(&qp); +} + +#endif + +#ifdef ENABLE_COMPLEX_DEPS + +#ifdef SUSE +static inline int +suse_isptf(Pool *pool, Solvable *s) +{ + if (!strncmp("ptf-", pool_id2str(pool, s->name), 4)) + return 1; + return 0; +} +#endif + +static void +add_complex_deprules(Solver *solv, Id p, Id dep, int type, int dontfix, Queue *workq, Map *m) +{ + Pool *pool = solv->pool; + Repo *installed = solv->installed; + int i, j, flags; + Queue bq; + + queue_init(&bq); + flags = dontfix ? CPLXDEPS_DONTFIX : 0; + /* CNF expansion for requires, DNF + INVERT expansion for conflicts */ + if (type == SOLVER_RULE_PKG_CONFLICTS) + flags |= CPLXDEPS_TODNF | CPLXDEPS_EXPAND | CPLXDEPS_INVERT; +#ifdef SUSE + if (type == SOLVER_RULE_PKG_REQUIRES && suse_isptf(pool, pool->solvables + p)) + flags |= CPLXDEPS_NAME; /* do not match provides */ +#endif + + i = pool_normalize_complex_dep(pool, dep, &bq, flags); + /* handle special cases */ + if (i == 0) + { + if (dontfix) + { + POOL_DEBUG(SOLV_DEBUG_RULE_CREATION, "ignoring broken dependency %s of installed package %s\n", pool_dep2str(pool, dep), pool_solvid2str(pool, p)); + } + else + { + POOL_DEBUG(SOLV_DEBUG_RULE_CREATION, "package %s [%d] is not installable (%s)\n", pool_solvid2str(pool, p), p, pool_dep2str(pool, dep)); + addpkgrule(solv, -p, 0, 0, type == SOLVER_RULE_PKG_REQUIRES ? SOLVER_RULE_PKG_NOTHING_PROVIDES_DEP : type, dep); + } + queue_free(&bq); + return; + } + if (i == 1) + { + queue_free(&bq); + return; + } + + /* go through all blocks and add a rule for each block */ + for (i = 0; i < bq.count; i++) + { + if (!bq.elements[i]) + continue; /* huh? */ + if (bq.elements[i] == pool->nsolvables) + { + /* conventional requires (cannot be a conflicts as they have been expanded) */ + Id *dp = pool->whatprovidesdata + bq.elements[i + 1]; + i += 2; + if (dontfix) + { + for (j = 0; dp[j] != 0; j++) + if (pool->solvables[dp[j]].repo == installed) + break; /* provider was installed */ + if (!dp[j]) + continue; + } + if (type == SOLVER_RULE_PKG_RECOMMENDS && !*dp) + continue; + /* check if the rule contains both p and -p */ + for (j = 0; dp[j] != 0; j++) + if (dp[j] == p) + break; + if (dp[j]) + continue; + addpkgrule(solv, -p, 0, dp - pool->whatprovidesdata, type, dep); + /* push all non-visited providers on the work queue */ + if (m) + for (; *dp; dp++) + if (!MAPTST(m, *dp)) + queue_push(workq, *dp); + continue; + } + if (!bq.elements[i + 1]) + { + Id p2 = bq.elements[i++]; + /* simple rule with just two literals, we'll add a (-p, p2) rule */ + if (dontfix) + { + if (p2 < 0 && pool->solvables[-p2].repo == installed) + continue; + if (p2 > 0 && pool->solvables[p2].repo != installed) + continue; + } + if (-p == p2) + { + if (type == SOLVER_RULE_PKG_CONFLICTS) + { + if (pool->forbidselfconflicts && !is_otherproviders_dep(pool, dep)) + addpkgrule(solv, -p, 0, 0, SOLVER_RULE_PKG_SELF_CONFLICT, dep); + continue; + } + addpkgrule(solv, -p, 0, 0, type, dep); + continue; + } + /* check if the rule contains both p and -p */ + if (p == p2) + continue; + addpkgrule(solv, -p, p2, 0, type, dep); + if (m && p2 > 0 && !MAPTST(m, p2)) + queue_push(workq, p2); + } + else + { + Id *qele, d; + int qcnt; + + qele = bq.elements + i; + qcnt = i; + while (bq.elements[i]) + i++; + qcnt = i - qcnt; + if (dontfix) + { + for (j = 0; j < qcnt; j++) + { + if (qele[j] > 0 && pool->solvables[qele[j]].repo == installed) + break; + if (qele[j] < 0 && pool->solvables[-qele[j]].repo != installed) + break; + } + if (j == qcnt) + continue; + } + /* add -p to (ordered) rule (overwriting the trailing zero) */ + for (j = 0; ; j++) + { + if (j == qcnt || qele[j] > -p) + { + if (j < qcnt) + memmove(qele + j + 1, qele + j, (qcnt - j) * sizeof(Id)); + qele[j] = -p; + qcnt++; + break; + } + if (qele[j] == -p) + break; + } + /* check if the rule contains both p and -p */ + for (j = 0; j < qcnt; j++) + if (qele[j] == p) + break; + if (j < qcnt) + continue; + d = pool_ids2whatprovides(pool, qele + 1, qcnt - 1); + if (solv->ruleinfoq && qele[0] != p) + { + int oldcount = solv->ruleinfoq->count; + addpkgrule(solv, qele[0], 0, d, type, dep); + /* fixup from element of ruleinfo */ + if (solv->ruleinfoq->count > oldcount && solv->ruleinfoq->elements[oldcount + 1] != p) + { + if (solv->ruleinfoq->elements[oldcount + 2]) + solv->ruleinfoq->elements[oldcount + 2] = solv->ruleinfoq->elements[oldcount + 1]; + solv->ruleinfoq->elements[oldcount + 1] = p; + } + } + else + addpkgrule(solv, qele[0], 0, d, type, dep); + if (m) + for (j = 0; j < qcnt; j++) + if (qele[j] > 0 && !MAPTST(m, qele[j])) + queue_push(workq, qele[j]); + } + } + queue_free(&bq); +} + +#endif + +#ifdef ENABLE_CONDA +void +add_conda_constrains_rule(Solver *solv, Id n, Id dep, int dontfix) +{ + Pool *pool = solv->pool; + Reldep *rd; + Id p, pp, pdep; + if (!ISRELDEP(dep)) + return; + rd = GETRELDEP(pool, dep); + pdep = pool_whatprovides(pool, dep); + FOR_PROVIDES(p, pp, rd->name) + { + Id p2; + if (p == n) + continue; + if (dontfix && pool->solvables[p].repo == solv->installed) + continue; + while ((p2 = pool->whatprovidesdata[pdep]) != 0 && p2 < p) + pdep++; + if (p == p2) + pdep++; + else + addpkgrule(solv, -n, -p, 0, SOLVER_RULE_PKG_CONSTRAINS, dep); + } } +#endif /*------------------------------------------------------------------- - * - * add (install) rules for solvable - * + * + * add dependency rules for solvable + * * s: Solvable for which to add rules * m: m[s] = 1 for solvables which have rules, prevent rule duplication - * + * * Algorithm: 'visit all nodes of a graph'. The graph nodes are * solvables, the edges their dependencies. * Starting from an installed solvable, this will create all rules * representing the graph created by the solvables dependencies. - * + * * for unfulfilled requirements, conflicts, obsoletes,.... * add a negative assertion for solvables that are not installable - * + * * It will also create rules for all solvables referenced by 's' * i.e. descend to all providers of requirements of 's' * */ void -solver_addrpmrulesforsolvable(Solver *solv, Solvable *s, Map *m) +solver_addpkgrulesforsolvable(Solver *solv, Solvable *s, Map *m) { Pool *pool = solv->pool; Repo *installed = solv->installed; - /* 'work' queue. keeps Ids of solvables we still have to work on. - And buffer for it. */ - Queue workq; + Queue workq; /* list of solvables we still have to work on */ Id workqbuf[64]; - + Queue depq; /* list of pre-req ids to ignore */ + Id depqbuf[16]; + int i; - /* if to add rules for broken deps ('rpm -V' functionality) - * 0 = yes, 1 = no - */ - int dontfix; - /* Id var and pointer for each dependency - * (not used in parallel) - */ + int dontfix; /* ignore dependency errors for installed solvables */ Id req, *reqp; Id con, *conp; Id obs, *obsp; @@ -475,11 +749,11 @@ solver_addrpmrulesforsolvable(Solver *solv, Solvable *s, Map *m) Id *dp; /* ptr to 'whatprovides' */ Id n; /* Id for current solvable 's' */ - POOL_DEBUG(SAT_DEBUG_SCHUBI, "----- addrpmrulesforsolvable -----\n"); - queue_init_buffer(&workq, workqbuf, sizeof(workqbuf)/sizeof(*workqbuf)); queue_push(&workq, s - pool->solvables); /* push solvable Id to work queue */ + queue_init_buffer(&depq, depqbuf, sizeof(depqbuf)/sizeof(*depqbuf)); + /* loop until there's no more work left */ while (workq.count) { @@ -496,38 +770,33 @@ solver_addrpmrulesforsolvable(Solver *solv, Solvable *s, Map *m) MAPSET(m, n); /* mark as visited */ } - s = pool->solvables + n; /* s = Solvable in question */ + s = pool->solvables + n; dontfix = 0; if (installed /* Installed system available */ && s->repo == installed /* solvable is installed */ - && !solv->fixmap_all /* NOT repair errors in rpm dependency graph */ + && !solv->fixmap_all /* NOT repair errors in dependency graph */ && !(solv->fixmap.size && MAPTST(&solv->fixmap, n - installed->start))) { - dontfix = 1; /* dont care about broken rpm deps */ + dontfix = 1; /* dont care about broken deps */ } - if (!dontfix - && s->arch != ARCH_SRC - && s->arch != ARCH_NOSRC - && !pool_installable(pool, s)) + if (!dontfix) { - POOL_DEBUG(SAT_DEBUG_RULE_CREATION, "package %s [%d] is not installable\n", solvable2str(pool, s), (Id)(s - pool->solvables)); - addrpmrule(solv, -n, 0, SOLVER_RULE_RPM_NOT_INSTALLABLE, 0); + if (s->arch == ARCH_SRC || s->arch == ARCH_NOSRC + ? pool_disabled_solvable(pool, s) + : !pool_installable(pool, s)) + { + POOL_DEBUG(SOLV_DEBUG_RULE_CREATION, "package %s [%d] is not installable\n", pool_solvid2str(pool, n), n); + addpkgrule(solv, -n, 0, 0, SOLVER_RULE_PKG_NOT_INSTALLABLE, 0); + } } - /* yet another SUSE hack, sigh */ - if (pool->nscallback && !strncmp("product:", id2str(pool, s->name), 8)) - { - Id buddy = pool->nscallback(pool, pool->nscallbackdata, NAMESPACE_PRODUCTBUDDY, n); - if (buddy > 0 && buddy != SYSTEMSOLVABLE && buddy != n && buddy < pool->nsolvables) - { - addrpmrule(solv, n, -buddy, SOLVER_RULE_RPM_PACKAGE_REQUIRES, solvable_selfprovidedep(pool->solvables + n)); - addrpmrule(solv, buddy, -n, SOLVER_RULE_RPM_PACKAGE_REQUIRES, solvable_selfprovidedep(pool->solvables + buddy)); - if (m && !MAPTST(m, buddy)) - queue_push(&workq, buddy); - } - } +#ifdef ENABLE_LINKED_PKGS + /* add pseudo-package <-> real-package links */ + if (has_package_link(pool, s)) + add_package_link(solv, s, m, &workq); +#endif /*----------------------------------------- * check requires of s @@ -535,11 +804,40 @@ solver_addrpmrulesforsolvable(Solver *solv, Solvable *s, Map *m) if (s->requires) { + int filterpre = 0; reqp = s->repo->idarraydata + s->requires; while ((req = *reqp++) != 0) /* go through all requires */ { if (req == SOLVABLE_PREREQMARKER) /* skip the marker */ - continue; + { + if (installed && s->repo == installed) + { + solvable_lookup_idarray(s, SOLVABLE_PREREQ_IGNOREINST, &depq); + filterpre = depq.count; + } + continue; + } + if (filterpre) + { + /* check if this id is filtered. assumes that depq.count is small */ + for (i = 0; i < depq.count; i++) + if (req == depq.elements[i]) + break; + if (i < depq.count) + { + POOL_DEBUG(SOLV_DEBUG_RULE_CREATION, "package %s: ignoring filtered pre-req dependency %s\n", pool_solvable2str(pool, s), pool_dep2str(pool, req)); + continue; + } + } + +#ifdef ENABLE_COMPLEX_DEPS + if (pool_is_complex_dep(pool, req)) + { + /* we have AND/COND deps, normalize */ + add_complex_deprules(solv, n, req, SOLVER_RULE_PKG_REQUIRES, dontfix, &workq, m); + continue; + } +#endif /* find list of solvables providing 'req' */ dp = pool_whatprovides_ptr(pool, req); @@ -553,54 +851,99 @@ solver_addrpmrulesforsolvable(Solver *solv, Solvable *s, Map *m) * that are already broken. so if we find one provider * that was already installed, we know that the * dependency was not broken before so we enforce it */ - - /* check if any of the providers for 'req' is installed */ for (i = 0; (p = dp[i]) != 0; i++) - { - if (pool->solvables[p].repo == installed) - break; /* provider was installed */ - } - /* didn't find an installed provider: previously broken dependency */ + if (pool->solvables[p].repo == installed) + break; /* found installed provider */ if (!p) { - POOL_DEBUG(SAT_DEBUG_RULE_CREATION, "ignoring broken requires %s of installed package %s\n", dep2str(pool, req), solvable2str(pool, s)); + /* didn't find an installed provider: previously broken dependency */ + POOL_DEBUG(SOLV_DEBUG_RULE_CREATION, "ignoring broken requires %s of installed package %s\n", pool_dep2str(pool, req), pool_solvable2str(pool, s)); continue; } } if (!*dp) { - /* nothing provides req! */ - POOL_DEBUG(SAT_DEBUG_RULE_CREATION, "package %s [%d] is not installable (%s)\n", solvable2str(pool, s), (Id)(s - pool->solvables), dep2str(pool, req)); - addrpmrule(solv, -n, 0, SOLVER_RULE_RPM_NOTHING_PROVIDES_DEP, req); + POOL_DEBUG(SOLV_DEBUG_RULE_CREATION, "package %s [%d] is not installable (%s)\n", pool_solvid2str(pool, n), n, pool_dep2str(pool, req)); + addpkgrule(solv, -n, 0, 0, SOLVER_RULE_PKG_NOTHING_PROVIDES_DEP, req); continue; } - IF_POOLDEBUG (SAT_DEBUG_RULE_CREATION) + for (i = 0; dp[i] != 0; i++) + if (n == dp[i]) + break; + if (dp[i]) + continue; /* provided by itself, no need to add rule */ + + IF_POOLDEBUG (SOLV_DEBUG_RULE_CREATION) { - POOL_DEBUG(SAT_DEBUG_RULE_CREATION," %s requires %s\n", solvable2str(pool, s), dep2str(pool, req)); + POOL_DEBUG(SOLV_DEBUG_RULE_CREATION," %s requires %s\n", pool_solvable2str(pool, s), pool_dep2str(pool, req)); for (i = 0; dp[i]; i++) - POOL_DEBUG(SAT_DEBUG_RULE_CREATION, " provided by %s\n", solvid2str(pool, dp[i])); + POOL_DEBUG(SOLV_DEBUG_RULE_CREATION, " provided by %s\n", pool_solvid2str(pool, dp[i])); } /* add 'requires' dependency */ /* rule: (-requestor|provider1|provider2|...|providerN) */ - addrpmrule(solv, -n, dp - pool->whatprovidesdata, SOLVER_RULE_RPM_PACKAGE_REQUIRES, req); + addpkgrule(solv, -n, 0, dp - pool->whatprovidesdata, SOLVER_RULE_PKG_REQUIRES, req); - /* descend the dependency tree - push all non-visited providers on the work queue */ + /* push all non-visited providers on the work queue */ if (m) + for (; *dp; dp++) + if (!MAPTST(m, *dp)) + queue_push(&workq, *dp); + } + } + + if (s->recommends && solv->strongrecommends) + { + int start = solv->nrules; + solv->lastpkgrule = 0; + reqp = s->repo->idarraydata + s->recommends; + while ((req = *reqp++) != 0) /* go through all recommends */ + { +#ifdef ENABLE_COMPLEX_DEPS + if (pool_is_complex_dep(pool, req)) { - for (; *dp; dp++) - { - if (!MAPTST(m, *dp)) - queue_push(&workq, *dp); - } + /* we have AND/COND deps, normalize */ + add_complex_deprules(solv, n, req, SOLVER_RULE_PKG_RECOMMENDS, dontfix, &workq, m); + continue; } +#endif + dp = pool_whatprovides_ptr(pool, req); + if (*dp == SYSTEMSOLVABLE || !*dp) /* always installed or not installable */ + continue; + for (i = 0; dp[i] != 0; i++) + if (n == dp[i]) + break; + if (dp[i]) + continue; /* provided by itself, no need to add rule */ + addpkgrule(solv, -n, 0, dp - pool->whatprovidesdata, SOLVER_RULE_PKG_RECOMMENDS, req); + if (m) + for (; *dp; dp++) + if (!MAPTST(m, *dp)) + queue_push(&workq, *dp); + } + if (!solv->ruleinfoq && start < solv->nrules) + { + if (!solv->recommendsruleq) + { + solv->recommendsruleq = solv_calloc(1, sizeof(Queue)); + queue_init(solv->recommendsruleq); + } + for (i = start; i < solv->nrules; i++) + queue_push(solv->recommendsruleq, i); + solv->lastpkgrule = 0; + } + } - } /* while, requirements of n */ - - } /* if, requirements */ +#ifdef ENABLE_CONDA + if (pool->disttype == DISTTYPE_CONDA) + { + solvable_lookup_idarray(s, SOLVABLE_CONSTRAINS, &depq); + for (i = 0; i < depq.count; i++) + add_conda_constrains_rule(solv, n, depq.elements[i], dontfix); + } +#endif /* that's all we check for src packages */ if (s->arch == ARCH_SRC || s->arch == ARCH_NOSRC) @@ -620,12 +963,20 @@ solver_addrpmrulesforsolvable(Solver *solv, Solvable *s, Map *m) * XXX: we should really handle this different, looking * at the name is a bad hack */ - if (!strncmp("patch:", id2str(pool, s->name), 6)) + if (!strncmp("patch:", pool_id2str(pool, s->name), 6)) ispatch = 1; conp = s->repo->idarraydata + s->conflicts; /* foreach conflicts of 's' */ while ((con = *conp++) != 0) { +#ifdef ENABLE_COMPLEX_DEPS + if (!ispatch && pool_is_complex_dep(pool, con)) + { + /* we have AND/COND deps, normalize */ + add_complex_deprules(solv, n, con, SOLVER_RULE_PKG_CONFLICTS, dontfix, &workq, m); + continue; + } +#endif /* foreach providers of a conflict of 's' */ FOR_PROVIDES(p, pp, con) { @@ -634,24 +985,27 @@ solver_addrpmrulesforsolvable(Solver *solv, Solvable *s, Map *m) /* dontfix: dont care about conflicts with already installed packs */ if (dontfix && pool->solvables[p].repo == installed) continue; - /* p == n: self conflict */ - if (p == n && !pool->allowselfconflicts) + if (p == n) /* p == n: self conflict */ { - if (ISRELDEP(con)) - { - Reldep *rd = GETRELDEP(pool, con); - if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_OTHERPROVIDERS) - continue; - } - p = 0; /* make it a negative assertion, aka 'uninstallable' */ + if (!pool->forbidselfconflicts || is_otherproviders_dep(pool, con)) + continue; + addpkgrule(solv, -n, 0, 0, SOLVER_RULE_PKG_SELF_CONFLICT, con); + continue; } - if (p && ispatch && solv->noobsoletes.size && MAPTST(&solv->noobsoletes, p) && ISRELDEP(con)) + if (ispatch && solv->multiversion.size && MAPTST(&solv->multiversion, p) && ISRELDEP(con)) { - /* our patch conflicts with a noobsoletes (aka multiversion) package */ - p = -makemultiversionconflict(solv, p, con); + /* our patch conflicts with a multiversion package */ + Id d = makemultiversionconflict(solv, p, con); + if (d) + { + addpkgrule(solv, -n, 0, d, SOLVER_RULE_PKG_CONFLICTS, con); + continue; + } } - /* rule: -n|-p: either solvable _or_ provider of conflict */ - addrpmrule(solv, -n, -p, p ? SOLVER_RULE_RPM_PACKAGE_CONFLICT : SOLVER_RULE_RPM_SELF_CONFLICT, con); + if (p == SYSTEMSOLVABLE) + p = 0; + /* rule: -n|-p: either solvable _or_ provider of conflict */ + addpkgrule(solv, -n, -p, 0, SOLVER_RULE_PKG_CONFLICTS, con); } } } @@ -663,15 +1017,15 @@ solver_addrpmrulesforsolvable(Solver *solv, Solvable *s, Map *m) */ if ((!installed || s->repo != installed) || !pool->noinstalledobsoletes) { - int noobs = solv->noobsoletes.size && MAPTST(&solv->noobsoletes, n); + int multi = solv->multiversion.size && MAPTST(&solv->multiversion, n); int isinstalled = (installed && s->repo == installed); - if (s->obsoletes && !noobs) + if (s->obsoletes && (!multi || solv->keepexplicitobsoletes)) { obsp = s->repo->idarraydata + s->obsoletes; /* foreach obsoletes */ while ((obs = *obsp++) != 0) { - /* foreach provider of an obsoletes of 's' */ + /* foreach provider of an obsoletes of 's' */ FOR_PROVIDES(p, pp, obs) { Solvable *ps = pool->solvables + p; @@ -684,10 +1038,12 @@ solver_addrpmrulesforsolvable(Solver *solv, Solvable *s, Map *m) continue; if (pool->obsoleteusescolors && !pool_colormatch(pool, s, ps)) continue; + if (p == SYSTEMSOLVABLE) + p = 0; if (!isinstalled) - addrpmrule(solv, -n, -p, SOLVER_RULE_RPM_PACKAGE_OBSOLETES, obs); + addpkgrule(solv, -n, -p, 0, SOLVER_RULE_PKG_OBSOLETES, obs); else - addrpmrule(solv, -n, -p, SOLVER_RULE_RPM_INSTALLEDPKG_OBSOLETES, obs); + addpkgrule(solv, -n, -p, 0, SOLVER_RULE_PKG_INSTALLED_OBSOLETES, obs); } } } @@ -707,28 +1063,68 @@ solver_addrpmrulesforsolvable(Solver *solv, Solvable *s, Map *m) continue; /* we still obsolete packages with same nevra, like rpm does */ /* (actually, rpm mixes those packages. yuck...) */ - if (noobs && (s->name != ps->name || s->evr != ps->evr || s->arch != ps->arch)) - continue; + if (multi && (s->name != ps->name || s->evr != ps->evr || s->arch != ps->arch)) + { + if (isinstalled || ps->repo != installed) + continue; + /* also check the installed package for multi-ness */ + if (MAPTST(&solv->multiversion, p)) + continue; + } if (!pool->implicitobsoleteusesprovides && s->name != ps->name) continue; - if (pool->obsoleteusescolors && !pool_colormatch(pool, s, ps)) + if (pool->implicitobsoleteusescolors && !pool_colormatch(pool, s, ps)) continue; + if (p == SYSTEMSOLVABLE) + p = 0; if (s->name == ps->name) - addrpmrule(solv, -n, -p, SOLVER_RULE_RPM_SAME_NAME, 0); + { + /* optimization: do not add the same-name conflict rule if it was + * already added when we looked at the other package. + * (this assumes pool_colormatch is symmetric) */ + if (p && m && ps->repo != installed && MAPTST(m, p) && + (ps->arch != ARCH_SRC && ps->arch != ARCH_NOSRC) && + !(solv->multiversion.size && MAPTST(&solv->multiversion, p))) + continue; + addpkgrule(solv, -n, -p, 0, SOLVER_RULE_PKG_SAME_NAME, 0); + } else - addrpmrule(solv, -n, -p, SOLVER_RULE_RPM_IMPLICIT_OBSOLETES, s->name); + addpkgrule(solv, -n, -p, 0, SOLVER_RULE_PKG_IMPLICIT_OBSOLETES, s->name); } } } + if (m && pool->implicitobsoleteusescolors && pool_arch2score(pool, s->arch) > 1) + { + unsigned int pa, a = pool_arch2score(pool, s->arch); + /* check lock-step candidates */ + FOR_PROVIDES(p, pp, s->name) + { + Solvable *ps = pool->solvables + p; + if (s->name != ps->name || s->evr != ps->evr || MAPTST(m, p)) + continue; + pa = pool_arch2score(pool, ps->arch); + if (!pa || pa == 1 || pa >= a) + continue; + queue_push(&workq, p); + } + } + /*----------------------------------------- - * add recommends to the work queue + * add recommends/suggests to the work queue */ if (s->recommends && m) { recp = s->repo->idarraydata + s->recommends; while ((rec = *recp++) != 0) { +#ifdef ENABLE_COMPLEX_DEPS + if (pool_is_complex_dep(pool, rec)) + { + pool_add_pos_literals_complex_dep(pool, rec, &workq, m, 0); + continue; + } +#endif FOR_PROVIDES(p, pp, rec) if (!MAPTST(m, p)) queue_push(&workq, p); @@ -739,52 +1135,96 @@ solver_addrpmrulesforsolvable(Solver *solv, Solvable *s, Map *m) sugp = s->repo->idarraydata + s->suggests; while ((sug = *sugp++) != 0) { +#ifdef ENABLE_COMPLEX_DEPS + if (pool_is_complex_dep(pool, sug)) + { + pool_add_pos_literals_complex_dep(pool, sug, &workq, m, 0); + continue; + } +#endif FOR_PROVIDES(p, pp, sug) if (!MAPTST(m, p)) queue_push(&workq, p); } } } + queue_free(&depq); queue_free(&workq); - POOL_DEBUG(SAT_DEBUG_SCHUBI, "----- addrpmrulesforsolvable end -----\n"); } +#ifdef ENABLE_LINKED_PKGS +void +solver_addpkgrulesforlinked(Solver *solv, Map *m) +{ + Pool *pool = solv->pool; + Solvable *s; + int i, j; + Queue qr; + + queue_init(&qr); + for (i = 1; i < pool->nsolvables; i++) + { + if (MAPTST(m, i)) + continue; + s = pool->solvables + i; + if (!s->repo || s->repo == solv->installed) + continue; + if (!strchr(pool_id2str(pool, s->name), ':')) + continue; + if (!pool_installable(pool, s)) + continue; + find_package_link(pool, s, 0, &qr, 0, 0); + if (qr.count) + { + for (j = 0; j < qr.count; j++) + if (MAPTST(m, qr.elements[j])) + { + solver_addpkgrulesforsolvable(solv, s, m); + break; + } + queue_empty(&qr); + } + } + queue_free(&qr); +} +#endif /*------------------------------------------------------------------- - * - * Add package rules for weak rules * - * m: visited solvables + * Add rules for packages possibly selected in by weak dependencies + * + * m: already added solvables */ void -solver_addrpmrulesforweak(Solver *solv, Map *m) +solver_addpkgrulesforweak(Solver *solv, Map *m) { Pool *pool = solv->pool; Solvable *s; Id sup, *supp; int i, n; - POOL_DEBUG(SAT_DEBUG_SCHUBI, "----- addrpmrulesforweak -----\n"); - /* foreach solvable in pool */ + /* foreach solvable in pool */ for (i = n = 1; n < pool->nsolvables; i++, n++) { if (i == pool->nsolvables) /* wrap i */ i = 1; - if (MAPTST(m, i)) /* been there */ + if (MAPTST(m, i)) /* already added that one */ continue; s = pool->solvables + i; - if (!pool_installable(pool, s)) /* only look at installable ones */ + if (!s->repo) continue; + if (s->repo != pool->installed && !pool_installable(pool, s)) + continue; /* only look at installable ones */ sup = 0; if (s->supplements) { /* find possible supplements */ supp = s->repo->idarraydata + s->supplements; - while ((sup = *supp++) != ID_NULL) - if (dep_possible(solv, sup, m)) + while ((sup = *supp++) != 0) + if (solver_dep_possible(solv, sup, m)) break; } @@ -792,31 +1232,30 @@ solver_addrpmrulesforweak(Solver *solv, Map *m) if (!sup && s->enhances) { supp = s->repo->idarraydata + s->enhances; - while ((sup = *supp++) != ID_NULL) - if (dep_possible(solv, sup, m)) + while ((sup = *supp++) != 0) + if (solver_dep_possible(solv, sup, m)) break; } /* if nothing found, goto next solvables */ if (!sup) continue; - solver_addrpmrulesforsolvable(solv, s, m); - n = 0; /* check all solvables again */ + solver_addpkgrulesforsolvable(solv, s, m); + n = 0; /* check all solvables again because we added solvables to m */ } - POOL_DEBUG(SAT_DEBUG_SCHUBI, "----- addrpmrulesforweak end -----\n"); } /*------------------------------------------------------------------- - * + * * add package rules for possible updates - * + * * s: solvable * m: map of already visited solvables * allow_all: 0 = dont allow downgrades, 1 = allow all candidates */ void -solver_addrpmrulesforupdaters(Solver *solv, Solvable *s, Map *m, int allow_all) +solver_addpkgrulesforupdaters(Solver *solv, Solvable *s, Map *m, int allow_all) { Pool *pool = solv->pool; int i; @@ -824,21 +1263,17 @@ solver_addrpmrulesforupdaters(Solver *solv, Solvable *s, Map *m, int allow_all) Queue qs; Id qsbuf[64]; - POOL_DEBUG(SAT_DEBUG_SCHUBI, "----- addrpmrulesforupdaters -----\n"); - queue_init_buffer(&qs, qsbuf, sizeof(qsbuf)/sizeof(*qsbuf)); /* find update candidates for 's' */ policy_findupdatepackages(solv, s, &qs, allow_all); /* add rule for 's' if not already done */ if (!MAPTST(m, s - pool->solvables)) - solver_addrpmrulesforsolvable(solv, s, m); + solver_addpkgrulesforsolvable(solv, s, m); /* foreach update candidate, add rule if not already done */ for (i = 0; i < qs.count; i++) if (!MAPTST(m, qs.elements[i])) - solver_addrpmrulesforsolvable(solv, pool->solvables + qs.elements[i], m); + solver_addpkgrulesforsolvable(solv, pool->solvables + qs.elements[i], m); queue_free(&qs); - - POOL_DEBUG(SAT_DEBUG_SCHUBI, "----- addrpmrulesforupdaters -----\n"); } @@ -850,63 +1285,139 @@ solver_addrpmrulesforupdaters(Solver *solv, Solvable *s, Map *m, int allow_all) *** ***/ -static Id -finddistupgradepackages(Solver *solv, Solvable *s, Queue *qs, int allow_all) +static int +dup_maykeepinstalled(Solver *solv, Solvable *s) { Pool *pool = solv->pool; - int i; + Id ip, pp; - policy_findupdatepackages(solv, s, qs, allow_all); - if (!qs->count) + if (solv->dupmap.size && MAPTST(&solv->dupmap, s - pool->solvables)) + return 1; + /* is installed identical to a good one? */ + FOR_PROVIDES(ip, pp, s->name) { - if (allow_all) - return 0; /* orphaned, don't create feature rule */ - /* check if this is an orphaned package */ - policy_findupdatepackages(solv, s, qs, 1); - if (!qs->count) - return 0; /* orphaned, don't create update rule */ - qs->count = 0; - return -SYSTEMSOLVABLE; /* supported but not installable */ + Solvable *is = pool->solvables + ip; + if (is->evr != s->evr) + continue; + if (solv->dupmap.size) + { + if (!MAPTST(&solv->dupmap, ip)) + continue; + } + else if (is->repo == pool->installed) + continue; + if (solvable_identical(s, is)) + return 1; } - if (allow_all) - return s - pool->solvables; - /* check if it is ok to keep the installed package */ - for (i = 0; i < qs->count; i++) + return 0; +} + + +/* stash away the original updaters for multiversion packages. We do this so that + * we can update the package later */ +static inline void +set_specialupdaters(Solver *solv, Solvable *s, Id d) +{ + Repo *installed = solv->installed; + if (!solv->specialupdaters) + solv->specialupdaters = solv_calloc(installed->end - installed->start, sizeof(Id)); + solv->specialupdaters[s - solv->pool->solvables - installed->start] = d; +} + +#ifdef ENABLE_LINKED_PKGS +/* Check if this is a linked pseudo package. As it is linked, we do not need an update/feature rule */ +static inline int +is_linked_pseudo_package(Solver *solv, Solvable *s) +{ + Pool *pool = solv->pool; + if (solv->instbuddy && solv->instbuddy[s - pool->solvables - solv->installed->start]) { - Solvable *ns = pool->solvables + qs->elements[i]; - if (s->evr == ns->evr && solvable_identical(s, ns)) - return s - pool->solvables; + const char *name = pool_id2str(pool, s->name); + if (strncmp(name, "pattern:", 8) == 0 || strncmp(name, "application:", 12) == 0) + return 1; } - /* nope, it must be some other package */ - return -SYSTEMSOLVABLE; + return 0; } +#endif -/* 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) +void +solver_addfeaturerule(Solver *solv, Solvable *s) { - Queue dupqs; - Id p, dupqsbuf[64]; + Pool *pool = solv->pool; int i; - int oldnoupdateprovide = solv->noupdateprovide; + Id p; + Queue qs; + Id qsbuf[64]; - 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++) +#ifdef ENABLE_LINKED_PKGS + if (is_linked_pseudo_package(solv, s)) { - p = dupqs.elements[i]; - if (MAPTST(&solv->dupmap, p)) - queue_pushunique(qs, p); + solver_addrule(solv, 0, 0, 0); /* no feature rules for those */ + return; + } +#endif + queue_init_buffer(&qs, qsbuf, sizeof(qsbuf)/sizeof(*qsbuf)); + p = s - pool->solvables; + policy_findupdatepackages(solv, s, &qs, 1); + if (solv->dupinvolvedmap_all || (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p))) + { + if (!dup_maykeepinstalled(solv, s)) + { + for (i = 0; i < qs.count; i++) + { + Solvable *ns = pool->solvables + qs.elements[i]; + if (ns->repo != pool->installed || dup_maykeepinstalled(solv, ns)) + break; + } + if (i == qs.count) + { + solver_addrule(solv, 0, 0, 0); /* this is an orphan */ + queue_free(&qs); + return; + } + } + } + if (qs.count > 1) + { + Id d = pool_queuetowhatprovides(pool, &qs); + queue_free(&qs); + solver_addrule(solv, p, 0, d); /* allow update of s */ + } + else + { + Id d = qs.count ? qs.elements[0] : 0; + queue_free(&qs); + solver_addrule(solv, p, d, 0); /* allow update of s */ + } +} + +/* check if multiversion solvable s2 has an obsoletes for installed solvable s */ +static int +is_multiversion_obsoleteed(Pool *pool, Solvable *s, Solvable *s2) +{ + Id *wp, obs, *obsp; + + if (pool->obsoleteusescolors && !pool_colormatch(pool, s, s2)) + return 0; + obsp = s2->repo->idarraydata + s2->obsoletes; + if (!pool->obsoleteusesprovides) + { + while ((obs = *obsp++) != 0) + if (pool_match_nevr(pool, s, obs)) + return 1; } - queue_free(&dupqs); + else + { + while ((obs = *obsp++) != 0) + for (wp = pool_whatprovides_ptr(pool, obs); *wp; wp++) + if (pool->solvables + *wp == s) + return 1; + } + return 0; } /*------------------------------------------------------------------- - * + * * add rule for update * (A|A1|A2|A3...) An = update candidates for A * @@ -914,68 +1425,128 @@ addduppackages(Solver *solv, Solvable *s, Queue *qs) */ void -solver_addupdaterule(Solver *solv, Solvable *s, int allow_all) +solver_addupdaterule(Solver *solv, Solvable *s) { /* installed packages get a special upgrade allowed rule */ Pool *pool = solv->pool; Id p, d; Queue qs; Id qsbuf[64]; + Rule *r; + int dupinvolved = 0; - POOL_DEBUG(SAT_DEBUG_SCHUBI, "----- addupdaterule -----\n"); - queue_init_buffer(&qs, qsbuf, sizeof(qsbuf)/sizeof(*qsbuf)); p = s - pool->solvables; + + if (pool->considered && pool_disabled_solvable(pool, s)) + { + /* disabled installed solvables must stay installed */ + solver_addrule(solv, p, 0, 0); + return; + } + + /* Orphan detection. We cheat by looking at the feature rule, which + * we already calculated */ + r = solv->rules + solv->featurerules + (p - solv->installed->start); + if (!r->p) + { +#ifdef ENABLE_LINKED_PKGS + if (is_linked_pseudo_package(solv, s)) + { + solver_addrule(solv, 0, 0, 0); + return; + } +#endif + p = 0; + queue_push(&solv->orphaned, s - pool->solvables); /* an orphaned package */ + if (solv->keep_orphans && !(solv->droporphanedmap_all || (solv->droporphanedmap.size && MAPTST(&solv->droporphanedmap, s - pool->solvables - solv->installed->start)))) + p = s - pool->solvables; /* keep this orphaned package installed */ + solver_addrule(solv, p, 0, 0); + return; + } + /* find update candidates for 's' */ - if (solv->dupmap_all) - p = finddistupgradepackages(solv, s, &qs, allow_all); - else - policy_findupdatepackages(solv, s, &qs, allow_all); - if (!allow_all && !solv->dupmap_all && solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p)) - addduppackages(solv, s, &qs); + 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 (!allow_all && qs.count && solv->noobsoletes.size) + if (qs.count && solv->multiversion.size) { int i, j; - d = pool_queuetowhatprovides(pool, &qs); - /* filter out all noobsoletes packages as they don't update */ - for (i = j = 0; i < qs.count; i++) + for (i = 0; i < qs.count; i++) + if (MAPTST(&solv->multiversion, qs.elements[i])) + break; + if (i < qs.count) { - if (MAPTST(&solv->noobsoletes, qs.elements[i])) + /* filter out all multiversion packages as they don't update */ + d = pool_queuetowhatprovides(pool, &qs); /* save qs away */ + for (j = i; i < qs.count; i++) + { + if (MAPTST(&solv->multiversion, qs.elements[i])) + { + Solvable *ps = pool->solvables + qs.elements[i]; + /* check if there is an explicit obsoletes */ + if (solv->keepexplicitobsoletes && ps->obsoletes && is_multiversion_obsoleteed(pool, s, ps)) + { + qs.elements[j++] = qs.elements[i]; + continue; + } + /* it's ok if they have same nevra */ + if (ps->name != s->name || ps->evr != s->evr || ps->arch != s->arch) + continue; + } + qs.elements[j++] = qs.elements[i]; + } + + if (j == 0 && dupinvolved && !dup_maykeepinstalled(solv, s)) { - /* it's ok if they have same nevra */ - Solvable *ps = pool->solvables + qs.elements[i]; - if (ps->name != s->name || ps->evr != s->evr || ps->arch != s->arch) - continue; + /* 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)))) + { + /* we need to keep the orphan */ + queue_free(&qs); + solver_addrule(solv, p, 0, 0); + return; + } + /* we can drop it as long as we update */ + j = qs.count; } - qs.elements[j++] = qs.elements[i]; - } - if (j < qs.count) - { - if (d && solv->installed && s->repo == solv->installed && - (solv->updatemap_all || (solv->updatemap.size && MAPTST(&solv->updatemap, s - pool->solvables - solv->installed->start)))) + + if (j < qs.count) /* filtered at least one package? */ { - if (!solv->multiversionupdaters) - solv->multiversionupdaters = sat_calloc(solv->installed->end - solv->installed->start, sizeof(Id)); - solv->multiversionupdaters[s - pool->solvables - solv->installed->start] = d; + 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; } - if (j == 0 && p == -SYSTEMSOLVABLE && solv->dupmap_all) + else { - queue_push(&solv->orphaned, s - pool->solvables); /* treat as orphaned */ - j = qs.count; + /* could fallthrough, but then we would do pool_queuetowhatprovides twice */ + queue_free(&qs); + solver_addrule(solv, p, 0, d); /* allow update of s */ + return; } - qs.count = j; } } - if (qs.count && p == -SYSTEMSOLVABLE) - p = queue_shift(&qs); - d = qs.count ? pool_queuetowhatprovides(pool, &qs) : 0; - queue_free(&qs); - solver_addrule(solv, p, d); /* allow update of s */ - POOL_DEBUG(SAT_DEBUG_SCHUBI, "----- addupdaterule end -----\n"); + if (qs.count > 1) + { + d = pool_queuetowhatprovides(pool, &qs); + queue_free(&qs); + solver_addrule(solv, p, 0, d); /* allow update of s */ + } + else + { + d = qs.count ? qs.elements[0] : 0; + queue_free(&qs); + solver_addrule(solv, p, d, 0); /* allow update of s */ + } } -static inline void +static inline void disableupdaterule(Solver *solv, Id p) { Rule *r; @@ -987,9 +1558,17 @@ disableupdaterule(Solver *solv, Id p) r = solv->rules + solv->featurerules + (p - solv->installed->start); if (r->p && r->d >= 0) solver_disablerule(solv, r); + if (solv->bestrules_info) + { + int i, ni; + ni = solv->bestrules_end - solv->bestrules; + for (i = solv->bestrules_up - solv->bestrules; i < ni; i++) + if (solv->bestrules_info[i] == p) + solver_disablerule(solv, solv->rules + solv->bestrules + i); + } } -static inline void +static inline void reenableupdaterule(Solver *solv, Id p) { Pool *pool = solv->pool; @@ -998,27 +1577,38 @@ reenableupdaterule(Solver *solv, Id p) MAPCLR(&solv->noupdate, p - solv->installed->start); r = solv->rules + solv->updaterules + (p - solv->installed->start); if (r->p) - { - if (r->d >= 0) - return; - solver_enablerule(solv, r); - IF_POOLDEBUG (SAT_DEBUG_SOLUTIONS) + { + if (r->d < 0) { - POOL_DEBUG(SAT_DEBUG_SOLUTIONS, "@@@ re-enabling "); - solver_printruleclass(solv, SAT_DEBUG_SOLUTIONS, r); + solver_enablerule(solv, r); + IF_POOLDEBUG (SOLV_DEBUG_SOLUTIONS) + { + POOL_DEBUG(SOLV_DEBUG_SOLUTIONS, "@@@ re-enabling "); + solver_printruleclass(solv, SOLV_DEBUG_SOLUTIONS, r); + } } - return; } - r = solv->rules + solv->featurerules + (p - solv->installed->start); - if (r->p && r->d < 0) + else { - solver_enablerule(solv, r); - IF_POOLDEBUG (SAT_DEBUG_SOLUTIONS) + r = solv->rules + solv->featurerules + (p - solv->installed->start); + if (r->p && r->d < 0) { - POOL_DEBUG(SAT_DEBUG_SOLUTIONS, "@@@ re-enabling "); - solver_printruleclass(solv, SAT_DEBUG_SOLUTIONS, r); + solver_enablerule(solv, r); + IF_POOLDEBUG (SOLV_DEBUG_SOLUTIONS) + { + POOL_DEBUG(SOLV_DEBUG_SOLUTIONS, "@@@ re-enabling "); + solver_printruleclass(solv, SOLV_DEBUG_SOLUTIONS, r); + } } } + if (solv->bestrules_info) + { + int i, ni; + ni = solv->bestrules_end - solv->bestrules; + for (i = solv->bestrules_up - solv->bestrules; i < ni; i++) + if (solv->bestrules_info[i] == p) + solver_enablerule(solv, solv->rules + solv->bestrules + i); + } } @@ -1035,13 +1625,17 @@ void solver_addinfarchrules(Solver *solv, Map *addedmap) { Pool *pool = solv->pool; + Repo *installed = pool->installed; int first, i, j; - Id p, pp, a, aa, bestarch; + Id p, pp, aa; + unsigned int a, bestscore; Solvable *s, *ps, *bests; Queue badq, allowedarchs; + Queue lsq; queue_init(&badq); queue_init(&allowedarchs); + queue_init(&lsq); solv->infarchrules = solv->nrules; for (i = 1; i < pool->nsolvables; i++) { @@ -1049,7 +1643,7 @@ solver_addinfarchrules(Solver *solv, Map *addedmap) continue; s = pool->solvables + i; first = i; - bestarch = 0; + bestscore = 0; bests = 0; queue_empty(&allowedarchs); FOR_PROVIDES(p, pp, s->name) @@ -1061,59 +1655,145 @@ solver_addinfarchrules(Solver *solv, Map *addedmap) first = 0; if (first) break; - a = ps->arch; - a = (a <= pool->lastarch) ? pool->id2arch[a] : 0; - if (a != 1 && pool->installed && ps->repo == pool->installed) + a = pool_arch2score(pool, ps->arch); + 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)) + if (a && a != 1 && (!bestscore || a < bestscore)) { - bestarch = a; + bestscore = a; bests = ps; } } if (first) - continue; + continue; /* not the first in the group */ + + if (!bestscore && allowedarchs.count > 1 && pool->implicitobsoleteusescolors) + { + for (j = 0; j < allowedarchs.count; j++) + { + a = pool_arch2score(pool, allowedarchs.elements[j]); + if (a && a != 1 && (!bestscore || a < bestscore)) + bestscore = a; + } + } + + if (!bestscore) + continue; /* did not find a score for this group */ + /* speed up common case where installed package already has best arch */ if (allowedarchs.count == 1 && bests && allowedarchs.elements[0] == bests->arch) allowedarchs.count--; /* installed arch is best */ + + if (allowedarchs.count && pool->implicitobsoleteusescolors && installed) + { + /* need an extra pass for lockstep checking: we only allow to keep an inferior arch + * if the corresponding installed package is not lock-stepped */ + queue_empty(&allowedarchs); + FOR_PROVIDES(p, pp, s->name) + { + Id p2, pp2; + ps = pool->solvables + p; + if (ps->name != s->name || ps->repo != installed || !MAPTST(addedmap, p)) + continue; + if (solv->dupinvolvedmap_all || (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p))) + continue; + a = pool_arch2score(pool, ps->arch); + if (!a) + { + queue_pushunique(&allowedarchs, ps->arch); /* strange arch, allow */ + continue; + } + if (a == 1 || ((a ^ bestscore) & 0xffff0000) == 0) + continue; + /* have installed package with inferior arch, check if lock-stepped */ + FOR_PROVIDES(p2, pp2, s->name) + { + Solvable *s2 = pool->solvables + p2; + unsigned int a2; + if (p2 == p || s2->name != s->name || s2->evr != pool->solvables[p].evr || s2->arch == pool->solvables[p].arch) + continue; + a2 = pool_arch2score(pool, s2->arch); + if (a2 && (a2 == 1 || ((a2 ^ bestscore) & 0xffff0000) == 0)) + break; + } + if (!p2) + queue_pushunique(&allowedarchs, ps->arch); + } + } + + /* find all bad packages */ queue_empty(&badq); FOR_PROVIDES(p, pp, s->name) { ps = pool->solvables + p; if (ps->name != s->name || !MAPTST(addedmap, p)) continue; - a = ps->arch; - a = (a <= pool->lastarch) ? pool->id2arch[a] : 0; - if (a != 1 && bestarch && ((a ^ bestarch) & 0xffff0000) != 0) + a = pool_arch2score(pool, ps->arch); + if (a != 1 && ((a ^ bestscore) & 0xffff0000) != 0) { - if (pool->installed && ps->repo == pool->installed) - continue; /* always ok to keep an installed package */ + if (installed && ps->repo == installed) + { + if (pool->implicitobsoleteusescolors) + queue_push(&badq, p); /* special lock-step handling, see below */ + continue; /* always ok to keep an installed package */ + } for (j = 0; j < allowedarchs.count; j++) { + unsigned int aas; aa = allowedarchs.elements[j]; if (ps->arch == aa) break; - aa = (aa <= pool->lastarch) ? pool->id2arch[aa] : 0; - if (aa && ((a ^ aa) & 0xffff0000) == 0) + aas = pool_arch2score(pool, aa); + if (aas && ((a ^ aas) & 0xffff0000) == 0) break; /* compatible */ } if (j == allowedarchs.count) queue_push(&badq, p); } } - if (!badq.count) - continue; + /* block all solvables in the badq! */ for (j = 0; j < badq.count; j++) { p = badq.elements[j]; - solver_addrule(solv, -p, 0); + /* special lock-step handling */ + if (pool->implicitobsoleteusescolors) + { + Id p2; + int haveinstalled = 0; + queue_empty(&lsq); + FOR_PROVIDES(p2, pp, s->name) + { + Solvable *s2 = pool->solvables + p2; + if (p2 == p || s2->name != s->name || s2->evr != pool->solvables[p].evr || s2->arch == pool->solvables[p].arch) + continue; + a = pool_arch2score(pool, s2->arch); + if (a && (a == 1 || ((a ^ bestscore) & 0xffff000) == 0)) + { + queue_push(&lsq, p2); + if (installed && s2->repo == installed) + haveinstalled = 1; + } + } + if (installed && pool->solvables[p].repo == installed && !haveinstalled) + continue; /* installed package not in lock-step */ + if (lsq.count < 2) + solver_addrule(solv, -p, lsq.count ? lsq.elements[0] : 0, 0); + else + solver_addrule(solv, -p, 0, pool_queuetowhatprovides(pool, &lsq)); + } + else + { + solver_addrule(solv, -p, 0, 0); + } } } + queue_free(&lsq); queue_free(&badq); queue_free(&allowedarchs); solv->infarchrules_end = solv->nrules; @@ -1143,10 +1823,10 @@ reenableinfarchrule(Solver *solv, Id name) if (r->p < 0 && r->d < 0 && pool->solvables[-r->p].name == name) { solver_enablerule(solv, r); - IF_POOLDEBUG (SAT_DEBUG_SOLUTIONS) + IF_POOLDEBUG (SOLV_DEBUG_SOLUTIONS) { - POOL_DEBUG(SAT_DEBUG_SOLUTIONS, "@@@ re-enabling "); - solver_printruleclass(solv, SAT_DEBUG_SOLUTIONS, r); + POOL_DEBUG(SOLV_DEBUG_SOLUTIONS, "@@@ re-enabling "); + solver_printruleclass(solv, SOLV_DEBUG_SOLUTIONS, r); } } } @@ -1162,56 +1842,187 @@ reenableinfarchrule(Solver *solv, Id name) *** ***/ -void -solver_createdupmaps(Solver *solv) +static inline void +add_cleandeps_updatepkg(Solver *solv, Id p) +{ + if (!solv->cleandeps_updatepkgs) + { + solv->cleandeps_updatepkgs = solv_calloc(1, sizeof(Queue)); + queue_init(solv->cleandeps_updatepkgs); + } + queue_pushunique(solv->cleandeps_updatepkgs, p); +} + +static void +solver_addtodupmaps(Solver *solv, Id p, Id how, int targeted) { - Queue *job = &solv->job; Pool *pool = solv->pool; - Repo *repo; - Id how, what, p, pi, pp, obs, *obsp; - Solvable *s, *ps; - int i; + Solvable *ps, *s = pool->solvables + p; + Repo *installed = solv->installed; + Id pi, pip, obs, *obsp; - map_init(&solv->dupmap, pool->nsolvables); - map_init(&solv->dupinvolvedmap, pool->nsolvables); - for (i = 0; i < job->count; i += 2) + if (!solv->dupinvolvedmap.size) + map_grow(&solv->dupinvolvedmap, pool->nsolvables); + + MAPSET(&solv->dupinvolvedmap, p); + if (targeted) + MAPSET(&solv->dupmap, p); + FOR_PROVIDES(pi, pip, s->name) { - how = job->elements[i]; - what = job->elements[i + 1]; - switch (how & SOLVER_JOBMASK) + ps = pool->solvables + pi; + if (ps->name != s->name) + continue; + MAPSET(&solv->dupinvolvedmap, pi); + if (targeted && ps->repo == installed && solv->obsoletes && solv->obsoletes[pi - installed->start]) { - case SOLVER_DISTUPGRADE: - if ((how & SOLVER_SELECTMASK) != SOLVER_SOLVABLE_REPO) - break; - if (what <= 0 || what > pool->nrepos) - break; - repo = pool_id2repo(pool, what); - FOR_REPO_SOLVABLES(repo, p, s) + Id *opp, pi2; + for (opp = solv->obsoletes_data + solv->obsoletes[pi - installed->start]; (pi2 = *opp++) != 0;) + if (pool->solvables[pi2].repo != installed) + MAPSET(&solv->dupinvolvedmap, pi2); + } + 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_updatepkg(solv, pi); + if (!targeted && ps->repo != installed) + MAPSET(&solv->dupmap, pi); + } + if (s->repo == installed && solv->obsoletes && solv->obsoletes[p - installed->start]) + { + Id *opp; + for (opp = solv->obsoletes_data + solv->obsoletes[p - installed->start]; (pi = *opp++) != 0;) + { + ps = pool->solvables + pi; + if (ps->repo == installed) + continue; + MAPSET(&solv->dupinvolvedmap, pi); + if (!targeted) + MAPSET(&solv->dupmap, pi); + } + } + if (targeted && s->repo != installed && s->obsoletes) + { + /* XXX: check obsoletes/provides combination */ + obsp = s->repo->idarraydata + s->obsoletes; + while ((obs = *obsp++) != 0) + { + FOR_PROVIDES(pi, pip, obs) { - MAPSET(&solv->dupmap, p); - FOR_PROVIDES(pi, pp, s->name) + Solvable *ps = pool->solvables + pi; + if (!pool->obsoleteusesprovides && !pool_match_nevr(pool, ps, obs)) + continue; + if (pool->obsoleteusescolors && !pool_colormatch(pool, s, ps)) + continue; + MAPSET(&solv->dupinvolvedmap, pi); + if (targeted && ps->repo == installed && solv->obsoletes && solv->obsoletes[pi - installed->start]) { - ps = pool->solvables + pi; - if (ps->name != s->name) - continue; - MAPSET(&solv->dupinvolvedmap, pi); + Id *opp, pi2; + for (opp = solv->obsoletes_data + solv->obsoletes[pi - installed->start]; (pi2 = *opp++) != 0;) + if (pool->solvables[pi2].repo != installed) + MAPSET(&solv->dupinvolvedmap, pi2); } - if (s->obsoletes) + if (ps->repo == installed && (how & SOLVER_FORCEBEST) != 0 && !solv->bestupdatemap_all) { - /* FIXME: check obsoletes/provides combination */ - obsp = s->repo->idarraydata + s->obsoletes; - while ((obs = *obsp++) != 0) - { - FOR_PROVIDES(pi, pp, obs) - { - Solvable *pis = pool->solvables + pi; - if (!pool->obsoleteusesprovides && !pool_match_nevr(pool, pis, obs)) - continue; - if (pool->obsoleteusescolors && !pool_colormatch(pool, s, pis)) - continue; - MAPSET(&solv->dupinvolvedmap, pi); - } - } + 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_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) +{ + Pool *pool = solv->pool; + Queue *job = &solv->job; + Repo *installed = solv->installed; + Id select, how, what, p, pp; + Solvable *s; + int i, targeted; + + map_init(&solv->dupmap, pool->nsolvables); + solv->dupinvolvedmap_all = 0; + map_init(&solv->dupinvolvedmap, 0); + for (i = 0; i < job->count; i += 2) + { + how = job->elements[i]; + select = job->elements[i] & SOLVER_SELECTMASK; + what = job->elements[i + 1]; + switch (how & SOLVER_JOBMASK) + { + case SOLVER_DISTUPGRADE: + if (select == SOLVER_SOLVABLE_REPO) + { + Repo *repo; + if (what <= 0 || what > pool->nrepos) + break; + repo = pool_id2repo(pool, what); + if (!repo) + break; + if (repo != installed && !(how & SOLVER_TARGETED) && solv->noautotarget) + break; + targeted = repo != installed || (how & SOLVER_TARGETED) != 0; + FOR_REPO_SOLVABLES(repo, p, s) + { + if (repo != installed && !pool_installable(pool, s)) + continue; + solver_addtodupmaps(solv, p, how, targeted); + } + } + else if (select == SOLVER_SOLVABLE_ALL) + { + solv->dupinvolvedmap_all = 1; + FOR_POOL_SOLVABLES(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 + { + targeted = how & SOLVER_TARGETED ? 1 : 0; + if (installed && !targeted && !solv->noautotarget) + { + FOR_JOB_SELECT(p, pp, select, what) + if (pool->solvables[p].repo == installed) + break; + targeted = p == 0; + } + else if (!installed && !solv->noautotarget) + targeted = 1; + FOR_JOB_SELECT(p, pp, select, what) + { + Solvable *s = pool->solvables + p; + if (!s->repo) + continue; + if (s->repo != installed && !targeted) + continue; + if (s->repo != installed && !pool_installable(pool, s)) + continue; + solver_addtodupmaps(solv, p, how, targeted); } } break; @@ -1219,23 +2030,42 @@ solver_createdupmaps(Solver *solv) break; } } - MAPCLR(&solv->dupinvolvedmap, SYSTEMSOLVABLE); + if (solv->dupinvolvedmap.size) + MAPCLR(&solv->dupinvolvedmap, SYSTEMSOLVABLE); + /* set update for all involved installed packages. We need to do + * this before creating the update rules */ + if (solv->dupinvolvedmap_all) + solv->updatemap_all = 1; + else if (installed && !solv->updatemap_all && solv->dupinvolvedmap.size) + { + FOR_REPO_SOLVABLES(installed, p, s) + { + if (!MAPTST(&solv->dupinvolvedmap, p)) + continue; + if (!solv->updatemap.size) + map_grow(&solv->updatemap, installed->end - installed->start); + MAPSET(&solv->updatemap, p - installed->start); + } + } } void solver_freedupmaps(Solver *solv) { map_free(&solv->dupmap); - map_free(&solv->dupinvolvedmap); + /* we no longer free solv->dupinvolvedmap as we need it in + * policy's priority pruning code. sigh. */ } void solver_addduprules(Solver *solv, Map *addedmap) { Pool *pool = solv->pool; + Repo *installed = solv->installed; Id p, pp; Solvable *s, *ps; int first, i; + Rule *r; solv->duprules = solv->nrules; for (i = 1; i < pool->nsolvables; i++) @@ -1253,13 +2083,12 @@ solver_addduprules(Solver *solv, Map *addedmap) first = 0; if (first) break; - if (!MAPTST(&solv->dupinvolvedmap, p)) + if (!solv->dupinvolvedmap_all && !MAPTST(&solv->dupinvolvedmap, p)) continue; - if (solv->installed && ps->repo == solv->installed) + if (installed && ps->repo == installed) { - if (!solv->updatemap.size) - map_grow(&solv->updatemap, solv->installed->end - solv->installed->start); - MAPSET(&solv->updatemap, p - solv->installed->start); + if (pool->considered && pool_disabled_solvable(pool, ps)) + continue; /* always keep disabled installed packages */ if (!MAPTST(&solv->dupmap, p)) { Id ip, ipp; @@ -1272,12 +2101,43 @@ solver_addduprules(Solver *solv, Map *addedmap) if (is->evr == ps->evr && solvable_identical(ps, is)) break; } - if (!ip) - solver_addrule(solv, -p, 0); /* no match, sorry */ + if (ip) + { + /* 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) + { + /* 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 == p && !r->d && !r->w2) + { + 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 */ } } else if (!MAPTST(&solv->dupmap, p)) - solver_addrule(solv, -p, 0); + solver_addrule(solv, -p, 0, 0); } } solv->duprules_end = solv->nrules; @@ -1290,33 +2150,207 @@ disableduprule(Solver *solv, Id name) Pool *pool = solv->pool; Rule *r; int i; - for (i = solv->duprules, r = solv->rules + i; i < solv->duprules_end; i++, r++) - { + for (i = solv->duprules, r = solv->rules + i; i < solv->duprules_end; i++, r++) + { if (r->p < 0 && r->d >= 0 && pool->solvables[-r->p].name == name) solver_disablerule(solv, r); - } + } } -static inline void +static inline void reenableduprule(Solver *solv, Id name) { Pool *pool = solv->pool; Rule *r; int i; - for (i = solv->duprules, r = solv->rules + i; i < solv->duprules_end; i++, r++) - { + for (i = solv->duprules, r = solv->rules + i; i < solv->duprules_end; i++, r++) + { if (r->p < 0 && r->d < 0 && pool->solvables[-r->p].name == name) { solver_enablerule(solv, r); - IF_POOLDEBUG (SAT_DEBUG_SOLUTIONS) + IF_POOLDEBUG (SOLV_DEBUG_SOLUTIONS) + { + POOL_DEBUG(SOLV_DEBUG_SOLUTIONS, "@@@ re-enabling "); + solver_printruleclass(solv, SOLV_DEBUG_SOLUTIONS, r); + } + } + } +} + +/*********************************************************************** + *** + *** Black rule part + ***/ + +static inline void +disableblackrule(Solver *solv, Id p) +{ + Rule *r; + int i; + for (i = solv->blackrules, r = solv->rules + i; i < solv->blackrules_end; i++, r++) + if (r->p == -p) + solver_disablerule(solv, r); +} + +static inline void +reenableblackrule(Solver *solv, Id p) +{ + Pool *pool = solv->pool; + Rule *r; + int i; + for (i = solv->blackrules, r = solv->rules + i; i < solv->blackrules_end; i++, r++) + if (r->p == -p) + { + solver_enablerule(solv, r); + IF_POOLDEBUG (SOLV_DEBUG_SOLUTIONS) + { + POOL_DEBUG(SOLV_DEBUG_SOLUTIONS, "@@@ re-enabling "); + solver_printruleclass(solv, SOLV_DEBUG_SOLUTIONS, r); + } + } +} + +void +solver_addblackrules(Solver *solv) +{ + Pool *pool = solv->pool; + Repo *installed = solv->installed; + Id how, select, what, p, pp; + Queue *job = &solv->job; + Map updatemap; + int i; + + map_init(&updatemap, 0); + solv->blackrules = solv->nrules; + if (installed) + { + for (i = 0; i < job->count; i += 2) + { + how = job->elements[i]; + select = job->elements[i] & SOLVER_SELECTMASK; + what = job->elements[i + 1]; + switch (how & SOLVER_JOBMASK) + { + case SOLVER_BLACKLIST: + FOR_JOB_SELECT(p, pp, select, what) + { + Solvable *s = pool->solvables + p; + if (s->repo != installed) + continue; + if (!updatemap.size) + map_grow(&updatemap, pool->ss.nstrings); + if (s->name > 0 && s->name < pool->ss.nstrings) + MAPSET(&updatemap, s->name); + } + } + } + } + for (i = 0; i < job->count; i += 2) + { + how = job->elements[i]; + select = job->elements[i] & SOLVER_SELECTMASK; + what = job->elements[i + 1]; + switch (how & SOLVER_JOBMASK) + { + case SOLVER_BLACKLIST: + FOR_JOB_SELECT(p, pp, select, what) { - POOL_DEBUG(SAT_DEBUG_SOLUTIONS, "@@@ re-enabling "); - solver_printruleclass(solv, SAT_DEBUG_SOLUTIONS, r); + Solvable *s = pool->solvables + p; + if (s->repo == installed) + continue; + if (updatemap.size && s->name > 0 && s->name < pool->ss.nstrings && MAPTST(&updatemap, s->name)) + continue; /* installed package with same name is already blacklisted */ + solver_addrule(solv, -p, 0, 0); } + break; } } + map_free(&updatemap); + solv->blackrules_end = solv->nrules; +} + +/*********************************************************************** + *** + *** Strict repo prio rule part + ***/ + +/* add rules to exclude solvables provided by lower + * precedence repositories */ +void solver_addstrictrepopriorules(struct s_Solver *solv, Map *addedmap) +{ + Pool *pool = solv->pool; + Solvable *s; + Id p, p2, pp2; + Map priomap; + int max_prio; + + map_init_clone(&priomap, addedmap); + solv->strictrepopriorules = solv->nrules; + + FOR_POOL_SOLVABLES(p) + { + if (!MAPTST(&priomap, p)) + continue; + + s = pool->solvables + p; + max_prio = s->repo->priority; + FOR_PROVIDES(p2, pp2, s->name) + { + Solvable *s2 = pool->solvables + p2; + if (s->name != s2->name) + continue; + if (s2->repo->priority > max_prio) + max_prio = s2->repo->priority; + } + + FOR_PROVIDES(p2, pp2, s->name) + { + Solvable *s2 = pool->solvables + p2; + if (s->name != s2->name || !MAPTST(&priomap, p2)) + continue; + MAPCLR(&priomap, p2); + if (pool->installed && s2->repo == pool->installed) + continue; + if (s2->repo->priority < max_prio) + solver_addrule(solv, -p2, 0, 0); + } + } + solv->strictrepopriorules_end = solv->nrules; + map_free(&priomap); +} + +static inline void +disablerepopriorule(Solver *solv, Id name) +{ + Pool *pool = solv->pool; + Rule *r; + int i; + for (i = solv->strictrepopriorules, r = solv->rules + i; i < solv->strictrepopriorules_end; i++, r++) + { + if (r->p < 0 && r->d >= 0 && pool->solvables[-r->p].name == name) + solver_disablerule(solv, r); + } } +static inline void +reenablerepopriorule(Solver *solv, Id name) +{ + Pool *pool = solv->pool; + Rule *r; + int i; + for (i = solv->strictrepopriorules, r = solv->rules + i; i < solv->strictrepopriorules_end; i++, r++) + { + if (r->p < 0 && r->d < 0 && pool->solvables[-r->p].name == name) + { + solver_enablerule(solv, r); + IF_POOLDEBUG (SOLV_DEBUG_SOLUTIONS) + { + POOL_DEBUG(SOLV_DEBUG_SOLUTIONS, "@@@ re-enabling "); + solver_printruleclass(solv, SOLV_DEBUG_SOLUTIONS, r); + } + } + } +} /*********************************************************************** *** @@ -1327,9 +2361,36 @@ reenableduprule(Solver *solv, Id name) *** ***/ -#define DISABLE_UPDATE 1 -#define DISABLE_INFARCH 2 -#define DISABLE_DUP 3 +#define DISABLE_UPDATE 1 +#define DISABLE_INFARCH 2 +#define DISABLE_DUP 3 +#define DISABLE_BLACK 4 +#define DISABLE_REPOPRIO 5 + +/* check if installed package p is in lock-step with another installed package */ +static int +installed_is_in_lockstep(Solver *solv, Id p) +{ + Pool *pool = solv->pool; + Repo *installed = solv->installed; + int rid; + Id pp, l; + Rule *r; + + if (!installed) + return 0; + for (rid = solv->infarchrules, r = solv->rules + rid; rid < solv->infarchrules_end; rid++, r++) + { + if (r->p >= 0) + continue; + if (pool->solvables[-r->p].repo != installed) + continue; + FOR_RULELITERALS(l, pp, r) + if (l == p) + return 1; + } + return 0; +} static void jobtodisablelist(Solver *solv, Id how, Id what, Queue *q) @@ -1338,17 +2399,82 @@ jobtodisablelist(Solver *solv, Id how, Id what, Queue *q) Id select, p, pp; Repo *installed; Solvable *s; - int i; + int i, j, set, qstart; + Map omap; installed = solv->installed; select = how & SOLVER_SELECTMASK; switch (how & SOLVER_JOBMASK) { case SOLVER_INSTALL: - if ((select == SOLVER_SOLVABLE_NAME || select == SOLVER_SOLVABLE_PROVIDES) && solv->infarchrules != solv->infarchrules_end && ISRELDEP(what)) + set = how & SOLVER_SETMASK; + if (!(set & SOLVER_NOAUTOSET)) + { + /* automatically add set bits by analysing the job */ + if (select == SOLVER_SOLVABLE_NAME) + set |= SOLVER_SETNAME; + if (select == SOLVER_SOLVABLE) + set |= SOLVER_SETNAME | SOLVER_SETARCH | SOLVER_SETVENDOR | SOLVER_SETREPO | SOLVER_SETEVR; + else if ((select == SOLVER_SOLVABLE_NAME || select == SOLVER_SOLVABLE_PROVIDES) && ISRELDEP(what)) + { + Reldep *rd = GETRELDEP(pool, what); + if (rd->flags == REL_EQ && select == SOLVER_SOLVABLE_NAME) + { + if (pool->disttype != DISTTYPE_DEB) + { + const char *rel = strrchr(pool_id2str(pool, rd->evr), '-'); + set |= rel ? SOLVER_SETEVR : SOLVER_SETEV; + } + else + set |= SOLVER_SETEVR; + } + if (rd->flags <= 7 && ISRELDEP(rd->name)) + rd = GETRELDEP(pool, rd->name); + if (rd->flags == REL_ARCH) + set |= SOLVER_SETARCH; + } + } + else + set &= ~SOLVER_NOAUTOSET; + if (!set) + return; + if ((set & SOLVER_SETARCH) != 0 && solv->infarchrules != solv->infarchrules_end) { - Reldep *rd = GETRELDEP(pool, what); - if (rd->flags == REL_ARCH) + if (select == SOLVER_SOLVABLE) + { + for (i = solv->infarchrules; i < solv->infarchrules_end; i++) + if (solv->rules[i].p == -what) + break; + if (i < solv->infarchrules_end) + queue_push2(q, DISABLE_INFARCH, pool->solvables[what].name); + } + else + { + int qcnt = q->count; + /* does not work for SOLVER_SOLVABLE_ALL and SOLVER_SOLVABLE_REPO, but + they are not useful for SOLVER_INSTALL jobs anyway */ + FOR_JOB_SELECT(p, pp, select, what) + { + s = pool->solvables + p; + /* unify names */ + for (i = qcnt; i < q->count; i += 2) + if (q->elements[i + 1] == s->name) + break; + if (i < q->count) + continue; /* already have that DISABLE_INFARCH element */ + for (i = solv->infarchrules; i < solv->infarchrules_end; i++) + if (solv->rules[i].p == -p) + break; + if (i < solv->infarchrules_end) + queue_push2(q, DISABLE_INFARCH, s->name); + } + } + } + if ((set & SOLVER_SETREPO) != 0 && solv->duprules != solv->duprules_end) + { + if (select == SOLVER_SOLVABLE) + queue_push2(q, DISABLE_DUP, pool->solvables[what].name); + else { int qcnt = q->count; FOR_JOB_SELECT(p, pp, select, what) @@ -1360,67 +2486,193 @@ jobtodisablelist(Solver *solv, Id how, Id what, Queue *q) break; if (i < q->count) continue; - queue_push2(q, DISABLE_INFARCH, s->name); + queue_push2(q, DISABLE_DUP, s->name); } } } - if (select != SOLVER_SOLVABLE) - break; - s = pool->solvables + what; - if (solv->infarchrules != solv->infarchrules_end) - queue_push2(q, DISABLE_INFARCH, s->name); - if (solv->duprules != solv->duprules_end) - queue_push2(q, DISABLE_DUP, s->name); - if (!installed) - return; - if (solv->noobsoletes.size && MAPTST(&solv->noobsoletes, what)) + if ((set & SOLVER_SETREPO) != 0 && solv->strictrepopriorules != solv->strictrepopriorules_end) { - /* XXX: remove if we always do distupgrade with DUP rules */ - if (solv->dupmap_all && s->repo == installed) - queue_push2(q, DISABLE_UPDATE, what); - return; + if (select == SOLVER_SOLVABLE) + queue_push2(q, DISABLE_REPOPRIO, pool->solvables[what].name); + else + { + int qcnt = q->count; + FOR_JOB_SELECT(p, pp, select, what) + { + s = pool->solvables + p; + /* unify names */ + for (i = qcnt; i < q->count; i += 2) + if (q->elements[i + 1] == s->name) + break; + if (i < q->count) + continue; + queue_push2(q, DISABLE_REPOPRIO, s->name); + } + } } - if (s->repo == installed) + if ((set & SOLVER_SETEVR) != 0 && solv->blackrules != solv->blackrules_end) + { + if (select == SOLVER_SOLVABLE) + queue_push2(q, DISABLE_BLACK, what); + else + { + FOR_JOB_SELECT(p, pp, select, what) + queue_push2(q, DISABLE_BLACK, p); + } + } + if (!installed || installed->end == installed->start) + return; + /* now the hard part: disable some update rules */ + + /* if the job asks for a single solvable to stay, disable the update rule */ + if (select == SOLVER_SOLVABLE && pool->solvables[what].repo == installed && solv->bestrules_info) + if ((set & (SOLVER_SETEVR | SOLVER_SETARCH | SOLVER_SETVENDOR)) == (SOLVER_SETEVR | SOLVER_SETARCH | SOLVER_SETVENDOR)) + { + int ni = solv->bestrules_end - solv->bestrules; + for (i = solv->bestrules_up - solv->bestrules; i < ni; i++) + if (solv->bestrules_info[i] == what) + { + queue_push2(q, DISABLE_UPDATE, what); /* will also disable the best rule */ + break; + } + return; + } + + /* first check if we have installed or multiversion packages in the job */ + FOR_JOB_SELECT(p, pp, select, what) { - queue_push2(q, DISABLE_UPDATE, what); - return; + if (pool->solvables[p].repo == installed) + return; + if (solv->multiversion.size && MAPTST(&solv->multiversion, p) && !solv->keepexplicitobsoletes) + return; /* will not obsolete anything, so just return */ } - if (s->obsoletes) + omap.size = 0; + qstart = q->count; + FOR_JOB_SELECT(p, pp, select, what) { - Id obs, *obsp; - obsp = s->repo->idarraydata + s->obsoletes; - while ((obs = *obsp++) != 0) - FOR_PROVIDES(p, pp, obs) - { - Solvable *ps = pool->solvables + p; - if (ps->repo != installed) - continue; - if (!pool->obsoleteusesprovides && !pool_match_nevr(pool, ps, obs)) - continue; - if (pool->obsoleteusescolors && !pool_colormatch(pool, s, ps)) - continue; - queue_push2(q, DISABLE_UPDATE, p); - } + solver_intersect_obsoleted(solv, p, q, qstart, &omap); + if (q->count == qstart) + break; } - FOR_PROVIDES(p, pp, s->name) + if (omap.size) + map_free(&omap); + + if (qstart == q->count) + return; /* nothing to prune */ + + /* convert result to (DISABLE_UPDATE, p) pairs */ + i = q->count; + for (j = qstart; j < i; j++) + queue_push(q, q->elements[j]); + for (j = qstart; j < q->count; j += 2) { - Solvable *ps = pool->solvables + p; - if (ps->repo != installed) - continue; - if (!pool->implicitobsoleteusesprovides && ps->name != s->name) - continue; - if (pool->obsoleteusescolors && !pool_colormatch(pool, s, ps)) - continue; - queue_push2(q, DISABLE_UPDATE, p); + q->elements[j] = DISABLE_UPDATE; + q->elements[j + 1] = q->elements[i++]; + } + + /* now that we know which installed packages are obsoleted check each of them */ + if ((set & (SOLVER_SETEVR | SOLVER_SETARCH | SOLVER_SETVENDOR)) == (SOLVER_SETEVR | SOLVER_SETARCH | SOLVER_SETVENDOR)) + return; /* all is set, nothing to do */ + + for (i = j = qstart; i < q->count; i += 2) + { + Solvable *is = pool->solvables + q->elements[i + 1]; + FOR_JOB_SELECT(p, pp, select, what) + { + int illegal = 0; + s = pool->solvables + p; + if ((set & SOLVER_SETEVR) != 0) + illegal |= POLICY_ILLEGAL_DOWNGRADE; /* ignore */ + if ((set & SOLVER_SETNAME) != 0) + illegal |= POLICY_ILLEGAL_NAMECHANGE; /* ignore */ + if ((set & SOLVER_SETARCH) != 0) + illegal |= POLICY_ILLEGAL_ARCHCHANGE; /* ignore */ + if ((set & SOLVER_SETVENDOR) != 0) + illegal |= POLICY_ILLEGAL_VENDORCHANGE; /* ignore */ + illegal = policy_is_illegal(solv, is, s, illegal); + if (illegal && illegal == POLICY_ILLEGAL_DOWNGRADE && (set & SOLVER_SETEV) != 0) + { + /* it's ok if the EV is different */ + if (pool_evrcmp(pool, is->evr, s->evr, EVRCMP_COMPARE_EVONLY) != 0) + illegal = 0; + } + if (illegal) + break; + } + if (!p) + { + /* no package conflicts with the update rule */ + /* thus keep the DISABLE_UPDATE */ + q->elements[j + 1] = q->elements[i + 1]; + j += 2; + } } + queue_truncate(q, j); return; + case SOLVER_ERASE: if (!installed) break; + set = how & SOLVER_SETMASK; + if (!(set & (SOLVER_NOAUTOSET | SOLVER_SETARCH)) && pool->implicitobsoleteusescolors && solv->infarchrules != solv->infarchrules_end) + { + if (select == SOLVER_SOLVABLE) + set |= SOLVER_SETARCH; + else if ((select == SOLVER_SOLVABLE_NAME || select == SOLVER_SOLVABLE_PROVIDES) && ISRELDEP(what)) + { + Reldep *rd = GETRELDEP(pool, what); + if (rd->flags <= 7 && ISRELDEP(rd->name)) + rd = GETRELDEP(pool, rd->name); + if (rd->flags == REL_ARCH) + set |= SOLVER_SETARCH; + } + } + if (select == SOLVER_SOLVABLE_ALL || (select == SOLVER_SOLVABLE_REPO && what == installed->repoid)) + { + FOR_REPO_SOLVABLES(installed, p, s) + queue_push2(q, DISABLE_UPDATE, p); + } FOR_JOB_SELECT(p, pp, select, what) if (pool->solvables[p].repo == installed) - queue_push2(q, DISABLE_UPDATE, p); + { + queue_push2(q, DISABLE_UPDATE, p); + if ((set & SOLVER_SETARCH) != 0 && pool->implicitobsoleteusescolors && solv->infarchrules != solv->infarchrules_end) + if (installed_is_in_lockstep(solv, p)) + queue_push2(q, DISABLE_INFARCH, pool->solvables[p].name); /* allow to break the lock-step */ +#ifdef ENABLE_LINKED_PKGS + if (solv->instbuddy && solv->instbuddy[p - installed->start] > 1) + queue_push2(q, DISABLE_UPDATE, solv->instbuddy[p - installed->start]); +#endif + } return; + + case SOLVER_LOCK: + if (!installed) + break; + qstart = q->count; + if (select == SOLVER_SOLVABLE_ALL || (select == SOLVER_SOLVABLE_REPO && what == installed->repoid)) + { + FOR_REPO_SOLVABLES(installed, p, s) + { + for (i = qstart; i < q->count; i += 2) + if (q->elements[i] == DISABLE_DUP && q->elements[i + 1] == pool->solvables[p].name) + break; + if (i == q->count) + queue_push2(q, DISABLE_DUP, pool->solvables[p].name); + } + } + FOR_JOB_SELECT(p, pp, select, what) + { + if (pool->solvables[p].repo != installed) + continue; + for (i = qstart; i < q->count; i += 2) + if (q->elements[i] == DISABLE_DUP && q->elements[i + 1] == pool->solvables[p].name) + break; + if (i == q->count) + queue_push2(q, DISABLE_DUP, pool->solvables[p].name); + } + break; + default: return; } @@ -1452,7 +2704,7 @@ solver_disablepolicyrules(Solver *solv) } if (solv->cleandepsmap.size) { - solver_createcleandepsmap(solv); + solver_createcleandepsmap(solv, &solv->cleandepsmap, 0); for (i = solv->installed->start; i < solv->installed->end; i++) if (MAPTST(&solv->cleandepsmap, i - solv->installed->start)) queue_push2(&allq, DISABLE_UPDATE, i); @@ -1472,6 +2724,12 @@ solver_disablepolicyrules(Solver *solv) case DISABLE_DUP: disableduprule(solv, arg); break; + case DISABLE_BLACK: + disableblackrule(solv, arg); + break; + case DISABLE_REPOPRIO: + disablerepopriorule(solv, arg); + break; default: break; } @@ -1485,17 +2743,46 @@ void solver_reenablepolicyrules(Solver *solv, int jobidx) { Queue *job = &solv->job; - int i, j; + int i, j, k, ai; Queue q, allq; Rule *r; Id lastjob = -1; - Id qbuf[32], allqbuf[128]; + Id qbuf[32], allqbuf[32]; queue_init_buffer(&q, qbuf, sizeof(qbuf)/sizeof(*qbuf)); - queue_init_buffer(&allq, allqbuf, sizeof(allqbuf)/sizeof(*allqbuf)); - jobtodisablelist(solv, job->elements[jobidx], job->elements[jobidx + 1], &q); + jobtodisablelist(solv, job->elements[jobidx - 1], job->elements[jobidx], &q); if (!q.count) - return; + { + queue_free(&q); + return; + } + /* now remove everything from q that is disabled by other jobs */ + + /* first remove cleandeps packages, they count as DISABLE_UPDATE */ + if (solv->cleandepsmap.size) + { + solver_createcleandepsmap(solv, &solv->cleandepsmap, 0); + for (j = k = 0; j < q.count; j += 2) + { + if (q.elements[j] == DISABLE_UPDATE) + { + Id p = q.elements[j + 1]; + if (p >= solv->installed->start && p < solv->installed->end && MAPTST(&solv->cleandepsmap, p - solv->installed->start)) + continue; /* remove element from q */ + } + q.elements[k++] = q.elements[j]; + q.elements[k++] = q.elements[j + 1]; + } + q.count = k; + if (!q.count) + { + queue_free(&q); + return; + } + } + + /* now go through the disable list of all other jobs */ + queue_init_buffer(&allq, allqbuf, sizeof(allqbuf)/sizeof(*allqbuf)); for (i = solv->jobrules; i < solv->jobrules_end; i++) { r = solv->rules + i; @@ -1506,22 +2793,35 @@ solver_reenablepolicyrules(Solver *solv, int jobidx) continue; lastjob = j; jobtodisablelist(solv, job->elements[j], job->elements[j + 1], &allq); + if (!allq.count) + continue; + /* remove all elements in allq from q */ + for (j = k = 0; j < q.count; j += 2) + { + Id type = q.elements[j], arg = q.elements[j + 1]; + for (ai = 0; ai < allq.count; ai += 2) + if (allq.elements[ai] == type && allq.elements[ai + 1] == arg) + break; + if (ai < allq.count) + continue; /* found it in allq, remove element from q */ + q.elements[k++] = q.elements[j]; + q.elements[k++] = q.elements[j + 1]; + } + q.count = k; + if (!q.count) + { + queue_free(&q); + queue_free(&allq); + return; + } + queue_empty(&allq); } - if (solv->cleandepsmap.size) - { - solver_createcleandepsmap(solv); - for (i = solv->installed->start; i < solv->installed->end; i++) - if (MAPTST(&solv->cleandepsmap, i - solv->installed->start)) - queue_push2(&allq, DISABLE_UPDATE, i); - } + queue_free(&allq); + + /* now re-enable anything that's left in q */ for (j = 0; j < q.count; j += 2) { Id type = q.elements[j], arg = q.elements[j + 1]; - for (i = 0; i < allq.count; i += 2) - if (allq.elements[i] == type && allq.elements[i + 1] == arg) - break; - if (i < allq.count) - continue; /* still disabled */ switch(type) { case DISABLE_UPDATE: @@ -1533,12 +2833,49 @@ solver_reenablepolicyrules(Solver *solv, int jobidx) case DISABLE_DUP: reenableduprule(solv, arg); break; + case DISABLE_BLACK: + reenableblackrule(solv, arg); + break; + case DISABLE_REPOPRIO: + reenablerepopriorule(solv, arg); + break; } } - queue_free(&allq); queue_free(&q); } +/* we just removed a package from the cleandeps map, now reenable all policy rules that were + * disabled because of this */ +void +solver_reenablepolicyrules_cleandeps(Solver *solv, Id pkg) +{ + Queue *job = &solv->job; + int i, j; + Queue allq; + Rule *r; + Id lastjob = -1; + Id allqbuf[128]; + + queue_init_buffer(&allq, allqbuf, sizeof(allqbuf)/sizeof(*allqbuf)); + for (i = solv->jobrules; i < solv->jobrules_end; i++) + { + r = solv->rules + i; + if (r->d < 0) /* disabled? */ + continue; + j = solv->ruletojob.elements[i - solv->jobrules]; + if (j == lastjob) + continue; + lastjob = j; + jobtodisablelist(solv, job->elements[j], job->elements[j + 1], &allq); + } + for (i = 0; i < allq.count; i += 2) + if (allq.elements[i] == DISABLE_UPDATE && allq.elements[i + 1] == pkg) + break; + if (i == allq.count) + reenableupdaterule(solv, pkg); + queue_free(&allq); +} + /*********************************************************************** *** @@ -1547,35 +2884,30 @@ solver_reenablepolicyrules(Solver *solv, int jobidx) ***/ static void -addrpmruleinfo(Solver *solv, Id p, Id d, int type, Id dep) +addpkgruleinfo(Solver *solv, Id p, Id p2, Id d, int type, Id dep) { Pool *pool = solv->pool; Rule *r; - Id w2, op, od, ow2; - - /* check if this creates the rule we're searching for */ - r = solv->rules + solv->ruleinfoq->elements[0]; - op = r->p; - od = r->d < 0 ? -r->d - 1 : r->d; - ow2 = 0; - - /* normalize */ - w2 = d > 0 ? 0 : d; - if (p < 0 && d > 0 && (!pool->whatprovidesdata[d] || !pool->whatprovidesdata[d + 1])) - { - w2 = pool->whatprovidesdata[d]; - d = 0; - } - if (p > 0 && d < 0) /* this hack is used for buddy deps */ + if (d) { - w2 = p; - p = d; + assert(!p2 && d > 0); + if (!pool->whatprovidesdata[d]) + d = 0; + else if (!pool->whatprovidesdata[d + 1]) + { + p2 = pool->whatprovidesdata[d]; + d = 0; + } } - if (d > 0) + /* check if this creates the rule we're searching for */ + r = solv->rules + solv->ruleinfoq->elements[0]; + if (d) { - if (p != op && !od) + /* three or more literals */ + Id od = r->d < 0 ? -r->d - 1 : r->d; + if (p != r->p && !od) return; if (d != od) { @@ -1587,43 +2919,34 @@ addrpmruleinfo(Solver *solv, Id p, Id d, int type, Id dep) if (*odp) return; } - w2 = 0; - /* handle multiversion conflict rules */ - if (p < 0 && pool->whatprovidesdata[d] < 0) - { - w2 = pool->whatprovidesdata[d]; - /* XXX: free memory */ - } + /* set p2 for multiversion conflicts */ + if (p < 0 && pool->whatprovidesdata[d] < 0 && pool->whatprovidesdata[d + 1] >= 0 && type == SOLVER_RULE_PKG_CONFLICTS) + p2 = pool->whatprovidesdata[d]; } else { - if (od) - return; - ow2 = r->w2; - if (p > w2) + /* one or two literals */ + Id op = p, op2 = p2; + if (op2 && op > op2) /* normalize */ { - if (w2 != op || p != ow2) - return; + Id o = op; + op = op2; + op2 = o; } - else + if (r->p != op || r->w2 != op2 || (r->d && r->d != -1)) + return; + if (type == SOLVER_RULE_PKG_CONFLICTS && !p2) + p2 = -SYSTEMSOLVABLE; + if (type == SOLVER_RULE_PKG_SAME_NAME) { - if (p != op || w2 != ow2) - return; + p = op; /* we normalize same name order */ + p2 = op2; } } /* yep, rule matches. record info */ queue_push(solv->ruleinfoq, type); - if (type == SOLVER_RULE_RPM_SAME_NAME) - { - /* we normalize same name order */ - queue_push(solv->ruleinfoq, op < 0 ? -op : 0); - queue_push(solv->ruleinfoq, ow2 < 0 ? -ow2 : 0); - } - else - { - queue_push(solv->ruleinfoq, p < 0 ? -p : 0); - queue_push(solv->ruleinfoq, w2 < 0 ? -w2 : 0); - } + queue_push(solv->ruleinfoq, p < 0 ? -p : 0); + queue_push(solv->ruleinfoq, p2 < 0 ? -p2 : 0); queue_push(solv->ruleinfoq, dep); } @@ -1648,15 +2971,47 @@ solver_allruleinfos_cmp(const void *ap, const void *bp, void *dp) return 0; } +static void +getpkgruleinfos(Solver *solv, Rule *r, Queue *rq) +{ + Pool *pool = solv->pool; + Id l, pp; + if (r->p >= 0) + return; + queue_push(rq, r - solv->rules); /* push the rule we're interested in */ + solv->ruleinfoq = rq; + FOR_RULELITERALS(l, pp, r) + { + if (l >= 0) + break; + solver_addpkgrulesforsolvable(solv, pool->solvables - l, 0); + } +#ifdef ENABLE_LINKED_PKGS + FOR_RULELITERALS(l, pp, r) + { + if (l < 0) + { + if (l == r->p) + continue; + break; + } + if (!strchr(pool_id2str(pool, pool->solvables[l].name), ':') || !has_package_link(pool, pool->solvables + l)) + break; + add_package_link(solv, pool->solvables + l, 0, 0); + } +#endif + solv->ruleinfoq = 0; + queue_shift(rq); +} + int solver_allruleinfos(Solver *solv, Id rid, Queue *rq) { - Pool *pool = solv->pool; Rule *r = solv->rules + rid; int i, j; queue_empty(rq); - if (rid <= 0 || rid >= solv->rpmrules_end) + if (rid <= 0 || rid >= solv->pkgrules_end) { Id type, from, to, dep; type = solver_ruleinfo(solv, rid, &from, &to, &dep); @@ -1666,26 +3021,17 @@ solver_allruleinfos(Solver *solv, Id rid, Queue *rq) queue_push(rq, dep); return 1; } - if (r->p >= 0) - return 0; - queue_push(rq, rid); - solv->ruleinfoq = rq; - solver_addrpmrulesforsolvable(solv, pool->solvables - r->p, 0); - /* also try reverse direction for conflicts */ - if ((r->d == 0 || r->d == -1) && r->w2 < 0) - solver_addrpmrulesforsolvable(solv, pool->solvables - r->w2, 0); - solv->ruleinfoq = 0; - queue_shift(rq); + getpkgruleinfos(solv, r, rq); /* now sort & unify em */ if (!rq->count) return 0; - sat_sort(rq->elements, rq->count / 4, 4 * sizeof(Id), solver_allruleinfos_cmp, 0); + solv_sort(rq->elements, rq->count / 4, 4 * sizeof(Id), solver_allruleinfos_cmp, 0); /* throw out identical entries */ for (i = j = 0; i < rq->count; i += 4) { if (j) { - if (rq->elements[i] == rq->elements[j - 4] && + if (rq->elements[i] == rq->elements[j - 4] && rq->elements[i + 1] == rq->elements[j - 3] && rq->elements[i + 2] == rq->elements[j - 2] && rq->elements[i + 3] == rq->elements[j - 1]) @@ -1713,32 +3059,26 @@ solver_ruleinfo(Solver *solv, Id rid, Id *fromp, Id *top, Id *depp) *top = 0; if (depp) *depp = 0; - if (rid > 0 && rid < solv->rpmrules_end) + if (rid > 0 && rid < solv->pkgrules_end) { Queue rq; int i; if (r->p >= 0) - return SOLVER_RULE_RPM; + return SOLVER_RULE_PKG; if (fromp) *fromp = -r->p; queue_init(&rq); - queue_push(&rq, rid); - solv->ruleinfoq = &rq; - solver_addrpmrulesforsolvable(solv, pool->solvables - r->p, 0); - /* also try reverse direction for conflicts */ - if ((r->d == 0 || r->d == -1) && r->w2 < 0) - solver_addrpmrulesforsolvable(solv, pool->solvables - r->w2, 0); - solv->ruleinfoq = 0; - type = SOLVER_RULE_RPM; - for (i = 1; i < rq.count; i += 4) + getpkgruleinfos(solv, r, &rq); + type = SOLVER_RULE_PKG; + for (i = 0; i < rq.count; i += 4) { Id qt, qo, qp, qd; qt = rq.elements[i]; qp = rq.elements[i + 1]; qo = rq.elements[i + 2]; qd = rq.elements[i + 3]; - if (type == SOLVER_RULE_RPM || type > qt) + if (type == SOLVER_RULE_PKG || qt == SOLVER_RULE_PKG_SAME_NAME || type > qt) { type = qt; if (fromp) @@ -1747,6 +3087,8 @@ solver_ruleinfo(Solver *solv, Id rid, Id *fromp, Id *top, Id *depp) *top = qo; if (depp) *depp = qd; + if (qt == SOLVER_RULE_PKG_SAME_NAME) + break; /* prefer SOLVER_RULE_PKG_SAME_NAME */ } } queue_free(&rq); @@ -1761,8 +3103,19 @@ solver_ruleinfo(Solver *solv, Id rid, Id *fromp, Id *top, Id *depp) *top = solv->job.elements[jidx]; if (depp) *depp = solv->job.elements[jidx + 1]; - if ((r->d == 0 || r->d == -1) && r->w2 == 0 && r->p == -SYSTEMSOLVABLE && (solv->job.elements[jidx] & SOLVER_SELECTMASK) != SOLVER_SOLVABLE_ONE_OF) - return SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP; + if ((r->d == 0 || r->d == -1) && r->w2 == 0 && r->p == -SYSTEMSOLVABLE) + { + Id how = solv->job.elements[jidx]; + if ((how & (SOLVER_JOBMASK|SOLVER_SELECTMASK)) == (SOLVER_INSTALL|SOLVER_SOLVABLE_NAME)) + return SOLVER_RULE_JOB_UNKNOWN_PACKAGE; + if ((how & (SOLVER_JOBMASK|SOLVER_SELECTMASK)) == (SOLVER_INSTALL|SOLVER_SOLVABLE_PROVIDES)) + return SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP; + if ((how & (SOLVER_JOBMASK|SOLVER_SELECTMASK)) == (SOLVER_ERASE|SOLVER_SOLVABLE_NAME)) + return SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM; + if ((how & (SOLVER_JOBMASK|SOLVER_SELECTMASK)) == (SOLVER_ERASE|SOLVER_SOLVABLE_PROVIDES)) + return SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM; + return SOLVER_RULE_JOB_UNSUPPORTED; + } return SOLVER_RULE_JOB; } if (rid >= solv->updaterules && rid < solv->updaterules_end) @@ -1793,146 +3146,442 @@ solver_ruleinfo(Solver *solv, Id rid, Id *fromp, Id *top, Id *depp) *depp = pool->solvables[-r->p].name; return SOLVER_RULE_INFARCH; } + if (rid >= solv->bestrules && rid < solv->bestrules_end) + { + /* > 0: the package we are updating */ + if (fromp && solv->bestrules_info[rid - solv->bestrules] > 0) + *fromp = solv->bestrules_info[rid - solv->bestrules]; + /* < 0: the job rule */ + if (top && solv->bestrules_info[rid - solv->bestrules] < 0) + *top = -solv->bestrules_info[rid - solv->bestrules]; + return SOLVER_RULE_BEST; + } + if (rid >= solv->yumobsrules && rid < solv->yumobsrules_end) + { + if (fromp) + *fromp = -r->p; + if (top) + { + /* first solvable is enough, we just need it for the name */ + if (!r->d || r->d == -1) + *top = r->w2; + else + *top = pool->whatprovidesdata[r->d < 0 ? -r->d : r->d]; + } + if (depp) + *depp = solv->yumobsrules_info[rid - solv->yumobsrules]; + return SOLVER_RULE_YUMOBS; + } + if (rid >= solv->blackrules && rid < solv->blackrules_end) + { + if (fromp) + *fromp = -r->p; + return SOLVER_RULE_BLACK; + } + if (rid >= solv->strictrepopriorules && rid < solv->strictrepopriorules_end) + { + if (fromp) + *fromp = -r->p; + return SOLVER_RULE_STRICT_REPO_PRIORITY; + } if (rid >= solv->choicerules && rid < solv->choicerules_end) { + if (solv->choicerules_info && fromp) + *fromp = solv->choicerules_info[rid - solv->choicerules]; return SOLVER_RULE_CHOICE; } - if (rid >= solv->learntrules) + if (rid >= solv->recommendsrules && rid < solv->recommendsrules_end) { - return SOLVER_RULE_LEARNT; + if (solv->recommendsrules_info && fromp) + *fromp = solv->recommendsrules_info[rid - solv->recommendsrules]; + return SOLVER_RULE_RECOMMENDS; } + if (rid >= solv->learntrules) + return SOLVER_RULE_LEARNT; + return SOLVER_RULE_UNKNOWN; +} + +SolverRuleinfo +solver_ruleclass(Solver *solv, Id rid) +{ + if (rid <= 0) + return SOLVER_RULE_UNKNOWN; + if (rid > 0 && rid < solv->pkgrules_end) + return SOLVER_RULE_PKG; + if (rid >= solv->jobrules && rid < solv->jobrules_end) + return SOLVER_RULE_JOB; + if (rid >= solv->updaterules && rid < solv->updaterules_end) + return SOLVER_RULE_UPDATE; + if (rid >= solv->featurerules && rid < solv->featurerules_end) + return SOLVER_RULE_FEATURE; + if (rid >= solv->duprules && rid < solv->duprules_end) + return SOLVER_RULE_DISTUPGRADE; + if (rid >= solv->infarchrules && rid < solv->infarchrules_end) + return SOLVER_RULE_INFARCH; + if (rid >= solv->bestrules && rid < solv->bestrules_end) + return SOLVER_RULE_BEST; + if (rid >= solv->yumobsrules && rid < solv->yumobsrules_end) + return SOLVER_RULE_YUMOBS; + if (rid >= solv->blackrules && rid < solv->blackrules_end) + return SOLVER_RULE_BLACK; + if (rid >= solv->choicerules && rid < solv->choicerules_end) + return SOLVER_RULE_CHOICE; + if (rid >= solv->recommendsrules && rid < solv->recommendsrules_end) + return SOLVER_RULE_RECOMMENDS; + if (rid >= solv->strictrepopriorules && rid < solv->strictrepopriorules_end) + return SOLVER_RULE_STRICT_REPO_PRIORITY; + if (rid >= solv->learntrules && rid < solv->nrules) + return SOLVER_RULE_LEARNT; return SOLVER_RULE_UNKNOWN; } void -solver_addchoicerules(Solver *solv) +solver_ruleliterals(Solver *solv, Id rid, Queue *q) { Pool *pool = solv->pool; - Map m, mneg; + Id p, pp; Rule *r; - Queue q, qi; - int i, j, rid, havechoice; - Id p, d, *pp; - Id p2, pp2; - Solvable *s, *s2; - solv->choicerules = solv->nrules; - if (!pool->installed) + queue_empty(q); + r = solv->rules + rid; + FOR_RULELITERALS(p, pp, r) + if (p != -SYSTEMSOLVABLE) + queue_push(q, p); + if (!q->count) + queue_push(q, -SYSTEMSOLVABLE); /* hmm, better to return an empty result? */ +} + +int +solver_rule2jobidx(Solver *solv, Id rid) +{ + if (rid < solv->jobrules || rid >= solv->jobrules_end) + return 0; + return solv->ruletojob.elements[rid - solv->jobrules] + 1; +} + +/* job rule introspection */ +Id +solver_rule2job(Solver *solv, Id rid, Id *whatp) +{ + int idx; + if (rid < solv->jobrules || rid >= solv->jobrules_end) { - solv->choicerules_end = solv->nrules; - return; + if (whatp) + *whatp = 0; + return 0; } - solv->choicerules_ref = sat_calloc(solv->rpmrules_end, sizeof(Id)); - queue_init(&q); - queue_init(&qi); - map_init(&m, pool->nsolvables); - map_init(&mneg, pool->nsolvables); - /* set up negative assertion map from infarch and dup rules */ - for (rid = solv->infarchrules, r = solv->rules + rid; rid < solv->infarchrules_end; rid++, r++) - if (r->p < 0 && !r->w2 && (r->d == 0 || r->d == -1)) - MAPSET(&mneg, -r->p); - for (rid = solv->duprules, r = solv->rules + rid; rid < solv->duprules_end; rid++, r++) - if (r->p < 0 && !r->w2 && (r->d == 0 || r->d == -1)) - MAPSET(&mneg, -r->p); - for (rid = 1; rid < solv->rpmrules_end ; rid++) + idx = solv->ruletojob.elements[rid - solv->jobrules]; + if (whatp) + *whatp = solv->job.elements[idx + 1]; + return solv->job.elements[idx]; +} + +/* update/feature rule introspection */ +Id +solver_rule2solvable(Solver *solv, Id rid) +{ + if (rid >= solv->updaterules && rid < solv->updaterules_end && solv->installed) + return solv->installed->start + (rid - solv->updaterules); + if (rid >= solv->featurerules && rid < solv->featurerules_end && solv->installed) + return solv->installed->start + (rid - solv->featurerules); + return 0; +} + +Id +solver_rule2pkgrule(Solver *solv, Id rid) +{ + if (rid >= solv->choicerules && rid < solv->choicerules_end) + return solv->choicerules_info[rid - solv->choicerules]; + if (rid >= solv->recommendsrules && rid < solv->recommendsrules_end) + return solv->recommendsrules_info[rid - solv->recommendsrules]; + return 0; +} + +static void +solver_rule2rules_rec(Solver *solv, Id rid, Queue *q, Map *seen) +{ + int i; + Id rid2; + + if (seen) + MAPSET(seen, rid); + for (i = solv->learnt_why.elements[rid - solv->learntrules]; (rid2 = solv->learnt_pool.elements[i]) != 0; i++) { - r = solv->rules + rid; - if (r->p >= 0 || ((r->d == 0 || r->d == -1) && r->w2 < 0)) - continue; /* only look at requires rules */ - // solver_printrule(solv, SAT_DEBUG_RESULT, r); - queue_empty(&q); - queue_empty(&qi); - havechoice = 0; - FOR_RULELITERALS(p, pp, r) + if (seen) { - if (p < 0) - continue; - s = pool->solvables + p; - if (!s->repo) + if (MAPTST(seen, rid2)) continue; - if (s->repo == pool->installed) - { - queue_push(&q, p); - continue; - } - /* check if this package is "blocked" by a installed package */ - s2 = 0; - FOR_PROVIDES(p2, pp2, s->name) - { - s2 = pool->solvables + p2; - if (s2->repo != pool->installed) - continue; - if (!pool->implicitobsoleteusesprovides && s->name != s2->name) - continue; - if (pool->obsoleteusescolors && !pool_colormatch(pool, s, s2)) - continue; - break; - } - if (p2) - { - /* found installed package p2 that we can update to p */ - if (!solv->allowarchchange && s->arch != s2->arch && policy_illegal_archchange(solv, s, s2)) - continue; - if (!solv->allowvendorchange && s->vendor != s2->vendor && policy_illegal_vendorchange(solv, s, s2)) - continue; - if (MAPTST(&mneg, p)) - continue; - queue_push(&qi, p2); - queue_push(&q, p); + if (rid2 >= solv->learntrules) + solver_rule2rules_rec(solv, rid2, q, seen); + continue; + } + queue_push(q, rid2); + } +} + +/* learnt rule introspection */ +void +solver_rule2rules(Solver *solv, Id rid, Queue *q, int recursive) +{ + queue_empty(q); + if (rid < solv->learntrules || rid >= solv->nrules) + return; + if (recursive) + { + Map seen; + map_init(&seen, solv->nrules); + solver_rule2rules_rec(solv, rid, q, &seen); + map_free(&seen); + } + else + solver_rule2rules_rec(solv, rid, q, 0); +} + + +/* check if the newest versions of pi still provides the dependency we're looking for */ +/* pi: installed package + * r: rule for the dependency + * m: map with all positive elements of r + * return 0: at least one provider + * return 1: the newest versions do not provide the dependency + */ +static int +solver_choicerulecheck(Solver *solv, Id pi, Rule *r, Map *m, Queue *q) +{ + Pool *pool = solv->pool; + Rule *ur; + Id p, pp; + int i; + + if (!q->count || q->elements[0] != pi) + { + if (q->count) + queue_empty(q); + ur = solv->rules + solv->updaterules + (pi - pool->installed->start); + if (!ur->p) + ur = solv->rules + solv->featurerules + (pi - pool->installed->start); + if (!ur->p) + return 0; + queue_push2(q, pi, 0); + FOR_RULELITERALS(p, pp, ur) + if (p > 0) + queue_push(q, p); + } + if (q->count == 2) + return 1; + if (q->count == 3) + { + p = q->elements[2]; + return MAPTST(m, p) ? 0 : 1; + } + if (!q->elements[1]) + { + for (i = 2; i < q->count; i++) + if (!MAPTST(m, q->elements[i])) + break; + if (i == q->count) + return 0; /* all provide it, no need to filter */ + /* some don't provide it, have to filter */ + queue_deleten(q, 0, 2); + policy_filter_unwanted(solv, q, POLICY_MODE_CHOOSE); + queue_unshift(q, 1); /* filter mark */ + queue_unshift(q, pi); + } + for (i = 2; i < q->count; i++) + if (MAPTST(m, q->elements[i])) + return 0; /* at least one provides it */ + return 1; /* none of the new packages provided it */ +} + +static Id +choicerule_find_installed(Pool *pool, Id p) +{ + Solvable *s = pool->solvables + p; + Id p2, pp2; + + if (!s->repo) + return 0; + if (s->repo == pool->installed) + return p; + FOR_PROVIDES(p2, pp2, s->name) + { + Solvable *s2 = pool->solvables + p2; + if (s2->repo != pool->installed) + continue; + if (!pool->implicitobsoleteusesprovides && s->name != s2->name) + continue; + if (pool->implicitobsoleteusescolors && !pool_colormatch(pool, s, s2)) + continue; + return p2; + } + if (s->obsoletes) + { + Id obs, *obsp = s->repo->idarraydata + s->obsoletes; + while ((obs = *obsp++) != 0) + { + FOR_PROVIDES(p2, pp2, obs) + { + Solvable *s2 = pool->solvables + p2; + if (s2->repo != pool->installed) + continue; + if (!pool->obsoleteusesprovides && !pool_match_nevr(pool, pool->solvables + p2, obs)) + continue; + if (pool->obsoleteusescolors && !pool_colormatch(pool, s, s2)) + continue; + return p2; + } + } + } + return 0; +} + +void +solver_addchoicerules(Solver *solv) +{ + Pool *pool = solv->pool; + Map m, mneg; + Rule *r; + Queue q, qi, qcheck, infoq; + int i, j, rid, havechoice, negcnt; + Id p, d, pp, p2; + Solvable *s; + Id lastaddedp, lastaddedd; + int lastaddedcnt; + unsigned int now; + int isinstalled; + int dodowngradecheck = solv->allowdowngrade; + + solv->choicerules = solv->nrules; + if (!pool->installed) + { + solv->choicerules_end = solv->nrules; + return; + } + now = solv_timems(0); + if ((solv->dupinvolvedmap_all || solv->dupinvolvedmap.size) && solv->dup_allowdowngrade) + dodowngradecheck = 1; + queue_init(&q); + queue_init(&qi); + queue_init(&qcheck); + queue_init(&infoq); + map_init(&m, pool->nsolvables); + map_init(&mneg, pool->nsolvables); + /* set up negative assertion map from infarch and dup rules */ + for (rid = solv->infarchrules, r = solv->rules + rid; rid < solv->infarchrules_end; rid++, r++) + if (r->p < 0 && !r->w2 && (r->d == 0 || r->d == -1)) + MAPSET(&mneg, -r->p); + for (rid = solv->duprules, r = solv->rules + rid; rid < solv->duprules_end; rid++, r++) + if (r->p < 0 && !r->w2 && (r->d == 0 || r->d == -1)) + MAPSET(&mneg, -r->p); + lastaddedp = 0; + lastaddedd = 0; + lastaddedcnt = 0; + for (rid = 1; rid < solv->pkgrules_end ; rid++) + { + r = solv->rules + rid; + if (r->p >= 0 || ((r->d == 0 || r->d == -1) && r->w2 <= 0)) + continue; /* only look at requires rules */ + /* solver_printrule(solv, SOLV_DEBUG_RESULT, r); */ + queue_empty(&qi); + havechoice = 0; + isinstalled = 0; + FOR_RULELITERALS(p, pp, r) + { + if (p < 0) + { + Solvable *s = pool->solvables - p; + p2 = s->repo == pool->installed ? -p : 0; + if (p2) + { + if (!(solv->updatemap_all || (solv->updatemap.size && MAPTST(&solv->updatemap, p2 - solv->installed->start)))) + isinstalled = 1; + } continue; } - if (s->obsoletes) + s = pool->solvables + p; + if (!s->repo) + continue; + if (s->repo == pool->installed) { - Id obs, *obsp = s->repo->idarraydata + s->obsoletes; - s2 = 0; - while ((obs = *obsp++) != 0) + queue_push2(&qi, p, p); + continue; + } + /* find an installed package p2 that we can update/downgrade to p */ + p2 = choicerule_find_installed(pool, p); + if (p2) + { + if (MAPTST(&mneg, p)) + continue; + if (policy_is_illegal(solv, pool->solvables + p2, s, 0)) + continue; + queue_push2(&qi, p2, p); + continue; + } + /* package p is independent of the installed ones */ + havechoice = 1; + } +#if 0 + printf("havechoice: %d qcount %d qicount %d\n", havechoice, q.count, qi.count); +#endif + if (!havechoice || !qi.count) + continue; /* no choice */ + + FOR_RULELITERALS(p, pp, r) + if (p > 0) + MAPSET(&m, p); + + if (!isinstalled) + { + /* do extra checking for packages related to installed packages */ + for (i = j = 0; i < qi.count; i += 2) + { + int isdowngrade = 0; + p2 = qi.elements[i]; + if (dodowngradecheck) { - FOR_PROVIDES(p2, pp2, obs) - { - s2 = pool->solvables + p2; - if (s2->repo != pool->installed) - continue; - if (!pool->obsoleteusesprovides && !pool_match_nevr(pool, pool->solvables + p2, obs)) - continue; - if (pool->obsoleteusescolors && !pool_colormatch(pool, s, s2)) - continue; - break; - } - if (p2) - break; + p = qi.elements[i + 1]; + if (pool->solvables[p2].name == pool->solvables[p].name) + if (pool_evrcmp(pool, pool->solvables[p2].evr, pool->solvables[p].evr, EVRCMP_COMPARE) > 0) + isdowngrade = 1; } - if (obs) + if (isdowngrade || solv->updatemap_all || (solv->updatemap.size && MAPTST(&solv->updatemap, p2 - solv->installed->start))) { - /* found installed package p2 that we can update to p */ - if (!solv->allowarchchange && s->arch != s2->arch && policy_illegal_archchange(solv, s, s2)) + if (solver_choicerulecheck(solv, p2, r, &m, &qcheck)) continue; - if (!solv->allowvendorchange && s->vendor != s2->vendor && policy_illegal_vendorchange(solv, s, s2)) - continue; - if (MAPTST(&mneg, p)) - continue; - queue_push(&qi, p2); - queue_push(&q, p); - continue; } + qi.elements[j++] = p2; + qi.elements[j++] = qi.elements[i + 1]; } - /* package p is independent of the installed ones */ - havechoice = 1; + queue_truncate(&qi, j); } - if (!havechoice || !q.count) - continue; /* no choice */ + + if (!qi.count) + { + FOR_RULELITERALS(p, pp, r) + if (p > 0) + MAPCLR(&m, p); + continue; + } + + queue_empty(&q); + /* split q from qi */ + for (i = j = 0; i < qi.count; i += 2) + { + queue_push(&q, qi.elements[i + 1]); + qi.elements[j++] = qi.elements[i]; + } + queue_truncate(&qi, j); + /* now check the update rules of the installed package. * if all packages of the update rules are contained in * the dependency rules, there's no need to set up the choice rule */ - map_empty(&m); - FOR_RULELITERALS(p, pp, r) - if (p > 0) - MAPSET(&m, p); for (i = 0; i < qi.count; i++) { + Rule *ur; if (!qi.elements[i]) continue; - Rule *ur = solv->rules + solv->updaterules + (qi.elements[i] - pool->installed->start); + ur = solv->rules + solv->updaterules + (qi.elements[i] - pool->installed->start); if (!ur->p) ur = solv->rules + solv->featurerules + (qi.elements[i] - pool->installed->start); if (!ur->p) @@ -1942,48 +3591,84 @@ solver_addchoicerules(Solver *solv) break; if (p) break; + /* speed improvement: only check each package once */ for (j = i + 1; j < qi.count; j++) if (qi.elements[i] == qi.elements[j]) qi.elements[j] = 0; } + /* empty map again */ + negcnt = 0; + FOR_RULELITERALS(p, pp, r) + if (p > 0) + MAPCLR(&m, p); + else + negcnt++; if (i == qi.count) { #if 0 printf("skipping choice "); - solver_printrule(solv, SAT_DEBUG_RESULT, solv->rules + rid); + solver_printrule(solv, SOLV_DEBUG_RESULT, solv->rules + rid); #endif continue; } + /* add neg elements to the front */ + if (negcnt > 1) + { + i = 0; + FOR_RULELITERALS(p, pp, r) + if (p < 0 && p != r->p) + queue_insert(&q, i++, p); + } + /* don't add identical rules */ + if (lastaddedp == r->p && lastaddedcnt == q.count) + { + for (i = 0; i < q.count; i++) + if (q.elements[i] != pool->whatprovidesdata[lastaddedd + i]) + break; + if (i == q.count) + continue; /* already added that one */ + } d = q.count ? pool_queuetowhatprovides(pool, &q) : 0; - solver_addrule(solv, r->p, d); + + lastaddedp = r->p; + lastaddedd = d; + lastaddedcnt = q.count; + + solver_addrule(solv, r->p, 0, d); queue_push(&solv->weakruleq, solv->nrules - 1); - solv->choicerules_ref[solv->nrules - 1 - solv->choicerules] = rid; + queue_push(&infoq, rid); #if 0 printf("OLD "); - solver_printrule(solv, SAT_DEBUG_RESULT, solv->rules + rid); + solver_printrule(solv, SOLV_DEBUG_RESULT, solv->rules + rid); printf("WEAK CHOICE "); - solver_printrule(solv, SAT_DEBUG_RESULT, solv->rules + solv->nrules - 1); + solver_printrule(solv, SOLV_DEBUG_RESULT, solv->rules + solv->nrules - 1); #endif } + if (infoq.count) + solv->choicerules_info = solv_memdup2(infoq.elements, infoq.count, sizeof(Id)); queue_free(&q); queue_free(&qi); + queue_free(&qcheck); + queue_free(&infoq); map_free(&m); map_free(&mneg); solv->choicerules_end = solv->nrules; + POOL_DEBUG(SOLV_DEBUG_STATS, "choice rule creation took %d ms\n", solv_timems(now)); } -/* called when a choice rule is disabled by analyze_unsolvable. We also - * have to disable all other choice rules so that the best packages get - * picked */ +/* called when a choice rule needs to be disabled by analyze_unsolvable. + * We also have to disable all other choice rules so that the best packages + * get picked */ void solver_disablechoicerules(Solver *solv, Rule *r) { - Id rid, p, *pp; + Id rid, p, pp; Pool *pool = solv->pool; Map m; Rule *or; - or = solv->rules + solv->choicerules_ref[(r - solv->rules) - solv->choicerules]; + solver_disablerule(solv, r); + or = solv->rules + solv->choicerules_info[(r - solv->rules) - solv->choicerules]; map_init(&m, pool->nsolvables); FOR_RULELITERALS(p, pp, or) if (p > 0) @@ -1996,304 +3681,797 @@ solver_disablechoicerules(Solver *solv, Rule *r) r = solv->rules + rid; if (r->d < 0) continue; - or = solv->rules + solv->choicerules_ref[(r - solv->rules) - solv->choicerules]; + or = solv->rules + solv->choicerules_info[rid - solv->choicerules]; FOR_RULELITERALS(p, pp, or) if (p > 0 && MAPTST(&m, p)) break; if (p) solver_disablerule(solv, r); } + map_free(&m); } -static void solver_createcleandepsmap(Solver *solv) +static void +prune_to_update_targets(Solver *solv, Id *cp, Queue *q) { - 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; - int i; - - map_init(&userinstalled, installed->end - installed->start); - map_init(&im, pool->nsolvables); - map_init(&installedm, pool->nsolvables); - map_empty(&solv->cleandepsmap); - queue_init(&iq); - - for (i = 0; i < job->count; i += 2) + int i, j; + Id p, *cp2; + for (i = j = 0; i < q->count; i++) { - how = job->elements[i]; - if ((how & SOLVER_JOBMASK) == SOLVER_USERINSTALLED) - { - what = job->elements[i + 1]; - select = how & SOLVER_SELECTMASK; - FOR_JOB_SELECT(p, pp, select, what) - if (pool->solvables[p].repo == installed) - MAPSET(&userinstalled, p - installed->start); - } + p = q->elements[i]; + for (cp2 = cp; *cp2; cp2++) + if (*cp2 == p) + { + q->elements[j++] = p; + break; + } } - /* add all positive elements (e.g. locks) to "userinstalled" */ - for (rid = solv->jobrules; rid < solv->jobrules_end; rid++) + queue_truncate(q, j); +} + +static void +prune_to_dup_packages(Solver *solv, Id p, Queue *q) +{ + int i, j; + for (i = j = 0; i < q->count; i++) { - r = solv->rules + rid; - if (r->d < 0) - continue; - FOR_RULELITERALS(p, jp, r) - if (p > 0 && pool->solvables[p].repo == installed) - MAPSET(&userinstalled, p - installed->start); + Id p = q->elements[i]; + if (MAPTST(&solv->dupmap, p)) + q->elements[j++] = p; } - for (rid = solv->jobrules; rid < solv->jobrules_end; rid++) + queue_truncate(q, j); +} + +static void +prune_best_update(Solver *solv, Id p, Queue *q) +{ + if (solv->update_targets && solv->update_targets->elements[p - solv->installed->start]) + prune_to_update_targets(solv, solv->update_targets->elements + solv->update_targets->elements[p - solv->installed->start], q); + if (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p)) + prune_to_dup_packages(solv, p, q); + /* select best packages, just look at prio and version */ + policy_filter_unwanted(solv, q, POLICY_MODE_RECOMMEND); +} + +static void +prune_disabled(Pool *pool, Queue *q) +{ + int i, j; + for (i = j = 0; i < q->count; i++) { - r = solv->rules + rid; - if (r->p >= 0 || r->d != 0) - continue; /* disabled or not erase */ - p = -r->p; - if (pool->solvables[p].repo != installed) + Id p = q->elements[i]; + Solvable *s = pool->solvables + p; + if (s->repo && s->repo != pool->installed && !MAPTST(pool->considered, p)) continue; - MAPCLR(&userinstalled, p - installed->start); - 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); + q->elements[j++] = p; } - for (p = installed->start; p < installed->end; p++) + queue_truncate(q, j); +} + +void +solver_addbestrules(Solver *solv, int havebestinstalljobs, int haslockjob) +{ + Pool *pool = solv->pool; + Id p; + Solvable *s; + Repo *installed = solv->installed; + Queue q, q2; + Rule *r; + Queue infoq; + int i, oldcnt; + Map *lockedmap = 0; + + solv->bestrules = solv->nrules; + queue_init(&q); + queue_init(&q2); + queue_init(&infoq); + + if (haslockjob) { - if (pool->solvables[p].repo != installed) - continue; - MAPSET(&installedm, p); - MAPSET(&im, p); + int i; + lockedmap = solv_calloc(1, sizeof(Map)); + map_init(lockedmap, pool->nsolvables); + for (i = 0, r = solv->rules + solv->jobrules; i < solv->ruletojob.count; i++, r++) + { + if (r->w2 || (solv->job.elements[solv->ruletojob.elements[i]] & SOLVER_JOBMASK) != SOLVER_LOCK) + continue; + p = r->p > 0 ? r->p : -r->p; + MAPSET(lockedmap, p); + } } - - while (iq.count) + if (havebestinstalljobs) { - ip = queue_shift(&iq); - if (!MAPTST(&im, ip)) - continue; - if (!MAPTST(&installedm, ip)) - continue; - if (MAPTST(&userinstalled, ip)) - continue; - MAPCLR(&im, ip); - s = pool->solvables + ip; -#ifdef CLEANDEPSDEBUG - printf("hello %s\n", solvable2str(pool, s)); -#endif - if (s->requires) + for (i = 0; i < solv->job.count; i += 2) { - reqp = s->repo->idarraydata + s->requires; - while ((req = *reqp++) != 0) + Id how = solv->job.elements[i]; + if ((how & (SOLVER_JOBMASK | SOLVER_FORCEBEST)) == (SOLVER_INSTALL | SOLVER_FORCEBEST)) { - if (req == SOLVABLE_PREREQMARKER) - continue; -#if 0 - /* count number of installed packages that match */ - count = 0; - FOR_PROVIDES(p, pp, req) - if (MAPTST(&installedm, p)) - count++; - if (count > 1) - continue; -#endif - FOR_PROVIDES(p, pp, req) + int j, k; + Id p2, pp2; + for (j = 0; j < solv->ruletojob.count; j++) { - if (MAPTST(&im, p)) + if (solv->ruletojob.elements[j] != i) + continue; + r = solv->rules + solv->jobrules + j; + queue_empty(&q); + queue_empty(&q2); + FOR_RULELITERALS(p2, pp2, r) { -#ifdef CLEANDEPSDEBUG - printf("%s requires %s\n", solvid2str(pool, ip), solvid2str(pool, p)); -#endif - queue_push(&iq, p); + if (p2 > 0) + queue_push(&q, p2); + else if (p2 < 0) + queue_push(&q2, p2); } + if (pool->considered && pool->whatprovideswithdisabled) + prune_disabled(pool, &q); + if (!q.count) + continue; /* orphaned */ + /* select best packages, just look at prio and version */ + oldcnt = q.count; + policy_filter_unwanted(solv, &q, POLICY_MODE_RECOMMEND); + if (q.count == oldcnt) + continue; /* nothing filtered */ + if (lockedmap) + { + queue_insertn(&q, 0, q2.count, q2.elements); + queue_empty(&q2); + FOR_RULELITERALS(p2, pp2, r) + { + if (p2 <= 0) + continue; + if (installed && pool->solvables[p2].repo == installed) + { + if (MAPTST(lockedmap, p2)) + queue_pushunique(&q, p2); /* we always want that package */ + } + else if (MAPTST(lockedmap, p2)) + continue; + queue_push(&q2, p2); + } + if (pool->considered && pool->whatprovideswithdisabled) + prune_disabled(pool, &q2); + policy_filter_unwanted(solv, &q2, POLICY_MODE_RECOMMEND); + for (k = 0; k < q2.count; k++) + queue_pushunique(&q, q2.elements[k]); + queue_empty(&q2); + } + if (q2.count) + queue_insertn(&q, 0, q2.count, q2.elements); + p2 = queue_shift(&q); + if (q.count < 2) + solver_addrule(solv, p2, q.count ? q.elements[0] : 0, 0); + else + solver_addrule(solv, p2, 0, pool_queuetowhatprovides(pool, &q)); + if ((how & SOLVER_WEAK) != 0) + queue_push(&solv->weakruleq, solv->nrules - 1); + queue_push(&infoq, -(solv->jobrules + j)); } } } - if (s->recommends) + } + solv->bestrules_up = solv->nrules; + + if (installed && (solv->bestupdatemap_all || solv->bestupdatemap.size)) + { + Map m; + + if (solv->allowuninstall || solv->allowuninstall_all || solv->allowuninstallmap.size) + map_init(&m, pool->nsolvables); + else + map_init(&m, 0); + FOR_REPO_SOLVABLES(installed, p, s) { - reqp = s->repo->idarraydata + s->recommends; - while ((req = *reqp++) != 0) + Id d, p2, pp2; + if (!solv->updatemap_all && (!solv->updatemap.size || !MAPTST(&solv->updatemap, p - installed->start))) + continue; + if (!solv->bestupdatemap_all && (!solv->bestupdatemap.size || !MAPTST(&solv->bestupdatemap, p - installed->start))) + continue; + queue_empty(&q); + if (solv->bestobeypolicy) + r = solv->rules + solv->updaterules + (p - installed->start); + else { -#if 0 - count = 0; - FOR_PROVIDES(p, pp, req) - if (MAPTST(&installedm, p)) - count++; - if (count > 1) - continue; -#endif - FOR_PROVIDES(p, pp, req) + r = solv->rules + solv->featurerules + (p - installed->start); + if (!r->p) /* identical to update rule? */ + r = solv->rules + solv->updaterules + (p - installed->start); + } + if (solv->specialupdaters && (d = solv->specialupdaters[p - installed->start]) != 0 && r == solv->rules + solv->updaterules + (p - installed->start)) + { + /* need to check specialupdaters */ + if (r->p == p) /* be careful with the dup case */ + queue_push(&q, p); + while ((p2 = pool->whatprovidesdata[d++]) != 0) + queue_push(&q, p2); + } + else + { + FOR_RULELITERALS(p2, pp2, r) + if (p2 > 0) + queue_push(&q, p2); + } + if (lockedmap) + { + queue_empty(&q2); + queue_insertn(&q2, 0, q.count, q.elements); + } + prune_best_update(solv, p, &q); + if (!q.count) + continue; /* orphaned */ + if (lockedmap) + { + int j; + /* always ok to keep installed locked packages */ + if (MAPTST(lockedmap, p)) + queue_pushunique(&q2, p); + for (j = 0; j < q2.count; j++) + { + Id p2 = q2.elements[j]; + if (pool->solvables[p2].repo == installed && MAPTST(lockedmap, p2)) + queue_pushunique(&q, p2); + } + /* filter out locked packages */ + for (i = j = 0; j < q2.count; j++) { - if (MAPTST(&im, p)) + Id p2 = q2.elements[j]; + if (pool->solvables[p2].repo == installed || !MAPTST(lockedmap, p2)) + q2.elements[i++] = p2; + } + queue_truncate(&q2, i); + prune_best_update(solv, p, &q2); + for (j = 0; j < q2.count; j++) + queue_pushunique(&q, q2.elements[j]); + } + if (solv->bestobeypolicy) + { + /* also filter the best of the feature rule packages and add them */ + r = solv->rules + solv->featurerules + (p - installed->start); + if (r->p) + { + int j; + queue_empty(&q2); + FOR_RULELITERALS(p2, pp2, r) + if (p2 > 0) + queue_push(&q2, p2); + prune_best_update(solv, p, &q2); + for (j = 0; j < q2.count; j++) + queue_pushunique(&q, q2.elements[j]); + if (lockedmap) { -#ifdef CLEANDEPSDEBUG - printf("%s recommends %s\n", solvid2str(pool, ip), solvid2str(pool, p)); -#endif - queue_push(&iq, p); + queue_empty(&q2); + FOR_RULELITERALS(p2, pp2, r) + if (p2 > 0) + if (pool->solvables[p2].repo == installed || !MAPTST(lockedmap, p2)) + queue_push(&q2, p2); + prune_best_update(solv, p, &q2); + for (j = 0; j < q2.count; j++) + queue_pushunique(&q, q2.elements[j]); } } } - } - if (!iq.count) - { - /* supplements pass */ - for (ip = solv->installed->start; ip < solv->installed->end; ip++) + if (solv->allowuninstall || solv->allowuninstall_all || (solv->allowuninstallmap.size && MAPTST(&solv->allowuninstallmap, p - installed->start))) { - if (!MAPTST(&installedm, ip)) - 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) && dep_possible(solv, sup, &installedm)) - break; - /* no longer supplemented, also erase */ - if (sup) + /* package is flagged both for allowuninstall and best, add negative rules */ + d = q.count == 1 ? q.elements[0] : -pool_queuetowhatprovides(pool, &q); + for (i = 0; i < q.count; i++) + MAPSET(&m, q.elements[i]); + r = solv->rules + solv->featurerules + (p - installed->start); + if (!r->p) /* identical to update rule? */ + r = solv->rules + solv->updaterules + (p - installed->start); + FOR_RULELITERALS(p2, pp2, r) { -#ifdef CLEANDEPSDEBUG - printf("%s supplemented\n", solvid2str(pool, ip)); -#endif - queue_push(&iq, ip); + if (MAPTST(&m, p2)) + continue; + if (d >= 0) + solver_addrule(solv, -p2, d, 0); + else + solver_addrule(solv, -p2, 0, -d); + queue_push(&infoq, p); } + for (i = 0; i < q.count; i++) + MAPCLR(&m, q.elements[i]); + continue; } + p2 = queue_shift(&q); + if (q.count < 2) + solver_addrule(solv, p2, q.count ? q.elements[0] : 0, 0); + else + solver_addrule(solv, p2, 0, pool_queuetowhatprovides(pool, &q)); + queue_push(&infoq, p); } + map_free(&m); } - - /* turn userinstalled into remove set for pruning */ - map_empty(&userinstalled); - for (rid = solv->jobrules; rid < solv->jobrules_end; rid++) + if (infoq.count) + solv->bestrules_info = solv_memdup2(infoq.elements, infoq.count, sizeof(Id)); + solv->bestrules_end = solv->nrules; + queue_free(&q); + queue_free(&q2); + queue_free(&infoq); + if (lockedmap) { - r = solv->rules + rid; - if (r->p >= 0 || r->d != 0) - continue; /* disabled or not erase */ - p = -r->p; - MAPCLR(&im, p); - if (pool->solvables[p].repo == installed) - MAPSET(&userinstalled, p - installed->start); + map_free(lockedmap); + solv_free(lockedmap); } - 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++) +} + + + + +/* yumobs rule handling */ +/* note that we use pool->obsoleteusescolors || pool->implicitobsoleteusescolors + * like in policy_findupdatepackages */ + +static void +find_obsolete_group(Solver *solv, Id obs, Queue *q) +{ + Pool *pool = solv->pool; + Queue qn; + Id p2, pp2, op, *opp, opp2; + int i, j, qnc, ncnt; + + queue_empty(q); + FOR_PROVIDES(p2, pp2, obs) { - r = solv->rules + rid; - if (r->d < 0) + Solvable *s2 = pool->solvables + p2; + if (s2->repo != pool->installed) continue; - FOR_RULELITERALS(p, jp, r) - if (p > 0) - queue_push(&iq, p); + if (!pool->obsoleteusesprovides && !pool_match_nevr(pool, pool->solvables + p2, obs)) + continue; + /* we obsolete installed package s2 with obs. now find all other packages that have the same dep */ + for (opp = solv->obsoletes_data + solv->obsoletes[p2 - solv->installed->start]; (op = *opp++) != 0;) + { + Solvable *os = pool->solvables + op; + Id obs2, *obsp2; + if (!os->obsoletes) + continue; + if ((pool->obsoleteusescolors || pool->implicitobsoleteusescolors) && !pool_colormatch(pool, s2, os)) + continue; + obsp2 = os->repo->idarraydata + os->obsoletes; + while ((obs2 = *obsp2++) != 0) + if (obs2 == obs) + break; + if (obs2) + queue_pushunique(q, op); + } + /* also search packages with the same name */ + FOR_PROVIDES(op, opp2, s2->name) + { + Solvable *os = pool->solvables + op; + Id obs2, *obsp2; + if (os->name != s2->name) + continue; + if (!os->obsoletes) + continue; + if ((pool->obsoleteusescolors || pool->implicitobsoleteusescolors) && !pool_colormatch(pool, s2, os)) + continue; + obsp2 = os->repo->idarraydata + os->obsoletes; + while ((obs2 = *obsp2++) != 0) + if (obs2 == obs) + break; + if (obs2) + queue_pushunique(q, op); + } } - /* also put directly addressed packages on the install queue - * so we can mark patterns as installed */ - for (i = 0; i < job->count; i += 2) + /* find names so that we can build groups */ + queue_init_clone(&qn, q); + prune_to_best_version(pool, &qn); +#if 0 +{ + for (i = 0; i < qn.count; i++) + printf(" + %s\n", pool_solvid2str(pool, qn.elements[i])); +} +#endif + /* filter into name groups */ + qnc = qn.count; + if (qnc == 1) { - how = job->elements[i]; - if ((how & SOLVER_JOBMASK) == SOLVER_USERINSTALLED) + queue_free(&qn); + queue_empty(q); + return; + } + ncnt = 0; + for (i = 0; i < qnc; i++) + { + Id n = pool->solvables[qn.elements[i]].name; + int got = 0; + for (j = 0; j < q->count; j++) { - what = job->elements[i + 1]; - select = how & SOLVER_SELECTMASK; - if (select == SOLVER_SOLVABLE && pool->solvables[what].repo != installed) - queue_push(&iq, what); + Id p = q->elements[j]; + if (pool->solvables[p].name == n) + { + queue_push(&qn, p); + got = 1; + } + } + if (got) + { + queue_push(&qn, 0); + ncnt++; } } - while (iq.count) + if (ncnt <= 1) + { + queue_empty(q); + } + else { - ip = queue_shift(&iq); - s = pool->solvables + ip; -#ifdef CLEANDEPSDEBUG - printf("bye %s\n", solvable2str(pool, s)); + queue_empty(q); + queue_insertn(q, 0, qn.count - qnc, qn.elements + qnc); + } + queue_free(&qn); +} + +void +solver_addyumobsrules(Solver *solv) +{ + Pool *pool = solv->pool; + Repo *installed = solv->installed; + Id p, op, *opp; + Solvable *s; + Queue qo, qq, infoq; + int i, j, k; + unsigned int now; + + solv->yumobsrules = solv->nrules; + if (!installed || !solv->obsoletes) + { + solv->yumobsrules_end = solv->nrules; + return; + } + now = solv_timems(0); + queue_init(&qo); + FOR_REPO_SOLVABLES(installed, p, s) + { + if (!solv->obsoletes[p - installed->start]) + continue; +#if 0 +printf("checking yumobs for %s\n", pool_solvable2str(pool, s)); #endif - if (s->requires) + for (opp = solv->obsoletes_data + solv->obsoletes[p - installed->start]; (op = *opp++) != 0;) { - reqp = s->repo->idarraydata + s->requires; - while ((req = *reqp++) != 0) + Solvable *os = pool->solvables + op; + Id obs, *obsp = os->repo->idarraydata + os->obsoletes; + Id p2, pp2; + while ((obs = *obsp++) != 0) { - FOR_PROVIDES(p, pp, req) + FOR_PROVIDES(p2, pp2, obs) { - if (!MAPTST(&im, p) && MAPTST(&installedm, p)) - { - if (p == ip) - continue; -#ifdef CLEANDEPSDEBUG - printf("%s requires %s\n", solvid2str(pool, ip), solvid2str(pool, p)); -#endif - MAPSET(&im, p); - queue_push(&iq, p); - } + Solvable *s2 = pool->solvables + p2; + if (s2->repo != installed) + continue; + if (!pool->obsoleteusesprovides && !pool_match_nevr(pool, pool->solvables + p2, obs)) + continue; + if ((pool->obsoleteusescolors || pool->implicitobsoleteusescolors) && !pool_colormatch(pool, s, s2)) + continue; + queue_pushunique(&qo, obs); + break; } } } - if (s->recommends) + } + if (!qo.count) + { + queue_free(&qo); + return; + } + queue_init(&infoq); + queue_init(&qq); + for (i = 0; i < qo.count; i++) + { + int group, groupk, groupstart; + queue_empty(&qq); +#if 0 +printf("investigating %s\n", pool_dep2str(pool, qo.elements[i])); +#endif + find_obsolete_group(solv, qo.elements[i], &qq); +#if 0 +printf("result:\n"); +for (j = 0; j < qq.count; j++) + if (qq.elements[j] == 0) + printf("---\n"); + else + printf("%s\n", pool_solvid2str(pool, qq.elements[j])); +#endif + + if (!qq.count) + continue; + /* at least two groups, build rules */ + group = 0; + for (j = 0; j < qq.count; j++) { - reqp = s->repo->idarraydata + s->recommends; - while ((req = *reqp++) != 0) + p = qq.elements[j]; + if (!p) + { + group++; + continue; + } + if (pool->solvables[p].repo == installed) + continue; + groupk = 0; + groupstart = 0; + for (k = 0; k < qq.count; k++) { - FOR_PROVIDES(p, pp, req) + Id pk = qq.elements[k]; + if (pk) + continue; + if (group != groupk && k > groupstart) { - if (!MAPTST(&im, p) && MAPTST(&installedm, p)) - { - if (p == ip) - continue; - if (MAPTST(&userinstalled, p - installed->start)) - continue; -#ifdef CLEANDEPSDEBUG - printf("%s recommends %s\n", solvid2str(pool, ip), solvid2str(pool, p)); -#endif - MAPSET(&im, p); - queue_push(&iq, p); - } + /* add the rule */ + if (k - groupstart == 1) + solver_addrule(solv, -p, qq.elements[groupstart], 0); + else + solver_addrule(solv, -p, 0, pool_ids2whatprovides(pool, qq.elements + groupstart, k - groupstart)); + queue_push(&infoq, qo.elements[i]); } + groupstart = k + 1; + groupk++; } } - if (!iq.count) + } + if (infoq.count) + solv->yumobsrules_info = solv_memdup2(infoq.elements, infoq.count, sizeof(Id)); + queue_free(&infoq); + queue_free(&qq); + queue_free(&qo); + solv->yumobsrules_end = solv->nrules; + POOL_DEBUG(SOLV_DEBUG_STATS, "yumobs rule creation took %d ms\n", solv_timems(now)); +} + +/* recommendsrules are a copy of some recommends package rule but + * with some disfavored literals removed */ +void +solver_addrecommendsrules(Solver *solv) +{ + Pool *pool = solv->pool; + int i, havedis, havepos; + Id p, pp; + Queue q, infoq; + + solv->recommendsrules = solv->nrules; + queue_init(&q); + queue_init(&infoq); + for (i = 0; i < solv->recommendsruleq->count; i++) + { + int rid = solv->recommendsruleq->elements[i]; + Rule *r = solv->rules + rid; + queue_empty(&q); + havedis = havepos = 0; + FOR_RULELITERALS(p, pp, r) { - /* supplements pass */ - for (ip = installed->start; ip < installed->end; ip++) + if (p > 0 && solv->favormap[p] < 0) + havedis = 1; + else { - if (!MAPTST(&installedm, ip)) - continue; - if (MAPTST(&userinstalled, ip - installed->start)) - continue; - s = pool->solvables + ip; - if (!s->supplements) - continue; - if (MAPTST(&im, ip) || !MAPTST(&installedm, 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", solvid2str(pool, ip)); -#endif - MAPSET(&im, ip); - queue_push(&iq, ip); - } + if (p > 0) + havepos = 1; + queue_push(&q, p); } } + if (!havedis) + continue; + solver_disablerule(solv, r); + if (!havepos || q.count < 2) + continue; + if (q.count == 2) + solver_addrule(solv, q.elements[0], q.elements[1], 0); + else + solver_addrule(solv, q.elements[0], 0, pool_ids2whatprovides(pool, q.elements + 1, q.count - 1)); + queue_push(&infoq, rid); } - - queue_free(&iq); - for (p = installed->start; p < installed->end; p++) + if (infoq.count) + solv->recommendsrules_info = solv_memdup2(infoq.elements, infoq.count, sizeof(Id)); + queue_free(&infoq); + queue_free(&q); + solv->recommendsrules_end = solv->nrules; +} + +void +solver_breakorphans(Solver *solv) +{ + Pool *pool = solv->pool; + Repo *installed = solv->installed; + int i, rid; + Map m; + + if (!installed || solv->droporphanedmap_all) + return; + solv->brokenorphanrules = solv_calloc(1, sizeof(Queue)); + queue_init(solv->brokenorphanrules); + map_init(&m, installed->end - installed->start); + for (i = 0; i < solv->orphaned.count; i++) { + Id p = solv->orphaned.elements[i]; if (pool->solvables[p].repo != installed) continue; - if (!MAPTST(&im, p)) - MAPSET(&solv->cleandepsmap, p - installed->start); + if (solv->droporphanedmap.size && MAPTST(&solv->droporphanedmap, p - installed->start)) + continue; + MAPSET(&m, p - installed->start); + } + for (rid = 1; rid < solv->pkgrules_end ; rid++) + { + Id p, *dp; + Rule *r = solv->rules + rid; + /* ignore non-deps and simple conflicts */ + if (r->p >= 0 || ((r->d == 0 || r->d == -1) && r->w2 < 0)) + continue; + p = -r->p; + if (p < installed->start || p >= installed->end || !MAPTST(&m, p - installed->start)) + { + /* need to check other literals */ + if (r->d == 0 || r->d == -1) + continue; + for (dp = pool->whatprovidesdata + (r->d < 0 ? -r->d - 1 : r->d); *dp < 0; dp++) + { + p = -*dp; + if (p >= installed->start && p < installed->end && MAPTST(&m, p - installed->start)) + break; + } + if (*dp >= 0) + continue; + } + /* ok, disable this rule */ + queue_push(solv->brokenorphanrules, rid); + if (r->d >= 0) + solver_disablerule(solv, r); + } + map_free(&m); + if (!solv->brokenorphanrules->count) + { + queue_free(solv->brokenorphanrules); + solv->brokenorphanrules = solv_free(solv->brokenorphanrules); } - map_free(&im); - map_free(&installedm); - map_free(&userinstalled); } +void +solver_check_brokenorphanrules(Solver *solv, Queue *dq) +{ + Pool *pool = solv->pool; + int i; + Id l, pp; -/* EOF */ + queue_empty(dq); + if (!solv->brokenorphanrules) + return; + for (i = 0; i < solv->brokenorphanrules->count; i++) + { + int rid = solv->brokenorphanrules->elements[i]; + Rule *r = solv->rules + rid; + FOR_RULELITERALS(l, pp, r) + { + if (l < 0) + { + if (solv->decisionmap[-l] <= 0) + break; + } + else + { + if (solv->decisionmap[l] > 0 && pool->solvables[l].repo != solv->installed) + break; + } + } + if (l) + continue; + FOR_RULELITERALS(l, pp, r) + if (l > 0 && solv->decisionmap[l] == 0 && pool->solvables[l].repo != solv->installed) + queue_pushunique(dq, l); + } +} + +const char * +solver_ruleinfo2str(Solver *solv, SolverRuleinfo type, Id source, Id target, Id dep) +{ + Pool *pool = solv->pool; + char *s; + Solvable *ss; + switch (type) + { + case SOLVER_RULE_DISTUPGRADE: + return pool_tmpjoin(pool, pool_solvid2str(pool, source), " does not belong to a distupgrade repository", 0); + case SOLVER_RULE_INFARCH: + return pool_tmpjoin(pool, pool_solvid2str(pool, source), " has inferior architecture", 0); + case SOLVER_RULE_UPDATE: + return pool_tmpjoin(pool, pool_solvid2str(pool, source), " needs to stay installed or be updated", 0); + case SOLVER_RULE_FEATURE: + return pool_tmpjoin(pool, pool_solvid2str(pool, source), " needs to stay installed or be updated/downgraded", 0); + case SOLVER_RULE_JOB: + return pool_tmpjoin(pool, "job ", pool_job2str(pool, target, dep, 0), 0); + case SOLVER_RULE_JOB_UNSUPPORTED: + return pool_tmpjoin(pool, "unsupported job ", pool_job2str(pool, target, dep, 0), 0); + case SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP: + return pool_tmpjoin(pool, "nothing provides requested ", pool_dep2str(pool, dep), 0); + case SOLVER_RULE_JOB_UNKNOWN_PACKAGE: + return pool_tmpjoin(pool, "requested package ", pool_dep2str(pool, dep), " does not exist"); + case SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM: + return pool_tmpjoin(pool, "requested ", pool_dep2str(pool, dep), " is provided by the system"); + case SOLVER_RULE_BEST: + if (source > 0) + return pool_tmpjoin(pool, "install best update candidate for ", pool_solvid2str(pool, source), 0); + if (target > 0) + { + target = solver_rule2job(solv, target, &dep); + return pool_tmpjoin(pool, "best package for job ", pool_job2str(pool, target, dep, 0), 0); + } + return "best rule"; + case SOLVER_RULE_PKG: + return "bad pkg rule type"; + case SOLVER_RULE_PKG_NOT_INSTALLABLE: + ss = pool->solvables + source; + if (pool_disabled_solvable(pool, ss)) + return pool_tmpjoin(pool, pool_solvid2str(pool, source), " is disabled", 0); + if (ss->arch && ss->arch != ARCH_SRC && ss->arch != ARCH_NOSRC && + pool->id2arch && pool_arch2score(pool, ss->arch) == 0) + return pool_tmpjoin(pool, pool_solvid2str(pool, source), " does not have a compatible architecture", 0); + return pool_tmpjoin(pool, pool_solvid2str(pool, source), " is not installable", 0); + case SOLVER_RULE_PKG_NOTHING_PROVIDES_DEP: + s = pool_tmpjoin(pool, "nothing provides ", pool_dep2str(pool, dep), 0); + return pool_tmpappend(pool, s, " needed by ", pool_solvid2str(pool, source)); + case SOLVER_RULE_PKG_SAME_NAME: + s = pool_tmpjoin(pool, "cannot install both ", pool_solvid2str(pool, source), 0); + return pool_tmpappend(pool, s, " and ", pool_solvid2str(pool, target)); + case SOLVER_RULE_PKG_CONFLICTS: + s = pool_tmpappend(pool, pool_solvid2str(pool, source), " conflicts with ", pool_dep2str(pool, dep)); + if (target) + s = pool_tmpappend(pool, s, " provided by ", pool_solvid2str(pool, target)); + return s; + case SOLVER_RULE_PKG_SELF_CONFLICT: + s = pool_tmpjoin(pool, pool_solvid2str(pool, source), " conflicts with ", 0); + return pool_tmpappend(pool, s, pool_dep2str(pool, dep), " provided by itself"); + case SOLVER_RULE_PKG_OBSOLETES: + s = pool_tmpappend(pool, pool_solvid2str(pool, source), " obsoletes ", pool_dep2str(pool, dep)); + if (target) + s = pool_tmpappend(pool, s, " provided by ", pool_solvid2str(pool, target)); + return s; + case SOLVER_RULE_PKG_INSTALLED_OBSOLETES: + s = pool_tmpjoin(pool, "installed ", pool_solvid2str(pool, source), 0); + s = pool_tmpappend(pool, s, " obsoletes ", pool_dep2str(pool, dep)); + if (target) + s = pool_tmpappend(pool, s, " provided by ", pool_solvid2str(pool, target)); + return s; + case SOLVER_RULE_PKG_IMPLICIT_OBSOLETES: + s = pool_tmpappend(pool, pool_solvid2str(pool, source), " implicitly obsoletes ", pool_dep2str(pool, dep)); + if (target) + s = pool_tmpappend(pool, s, " provided by ", pool_solvid2str(pool, target)); + return s; + case SOLVER_RULE_PKG_REQUIRES: + return pool_tmpjoin(pool, pool_solvid2str(pool, source), " requires ", pool_dep2str(pool, dep)); + case SOLVER_RULE_PKG_RECOMMENDS: + return pool_tmpjoin(pool, pool_solvid2str(pool, source), " recommends ", pool_dep2str(pool, dep)); + case SOLVER_RULE_PKG_CONSTRAINS: + s = pool_tmpappend(pool, pool_solvid2str(pool, source), " has constraint ", pool_dep2str(pool, dep)); + return pool_tmpappend(pool, s, " conflicting with ", pool_solvid2str(pool, target)); + case SOLVER_RULE_PKG_SUPPLEMENTS: + s = pool_tmpjoin(pool, pool_solvid2str(pool, source), " supplements ", pool_dep2str(pool, dep)); + if (target) + s = pool_tmpappend(pool, s, " provided by ", pool_solvid2str(pool, target)); + return s; + case SOLVER_RULE_YUMOBS: + s = pool_tmpjoin(pool, "both ", pool_solvid2str(pool, source), " and "); + s = pool_tmpjoin(pool, s, pool_solvid2str(pool, target), " obsolete "); + return pool_tmpappend(pool, s, pool_dep2str(pool, dep), 0); + case SOLVER_RULE_BLACK: + return pool_tmpjoin(pool, pool_solvid2str(pool, source), " can only be installed by a direct request", 0); + case SOLVER_RULE_STRICT_REPO_PRIORITY: + return pool_tmpjoin(pool, pool_solvid2str(pool, source), " is excluded by strict repo priority", 0); + case SOLVER_RULE_LEARNT: + return "learnt rule"; + case SOLVER_RULE_CHOICE: + if (source > 0) + { + const char *s2; + type = solver_ruleinfo(solv, source, &source, &target, &dep); + s2 = solver_ruleinfo2str(solv, type, source, target, dep); + return pool_tmpjoin(pool, s2, " (limited version)", 0); + } + return "choice rule"; + case SOLVER_RULE_RECOMMENDS: + if (source > 0) + { + const char *s2; + type = solver_ruleinfo(solv, source, &source, &target, &dep); + s2 = solver_ruleinfo2str(solv, type, source, target, dep); + return pool_tmpjoin(pool, s2, " (limited version)", 0); + } + return "recommends rule"; + default: + return "bad rule type"; + } +}