src/solverdebug.c

   1 /*
   2  * Copyright (c) 2008, Novell Inc.
   3  *
   4  * This program is licensed under the BSD license, read LICENSE.BSD
   5  * for further information
   6  */
   7
   8 /*
   9  * solverdebug.c
  10  *
  11  * debug functions for the SAT solver
  12  */
  13
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <unistd.h>
  17 #include <string.h>
  18 #include <assert.h>
  19
  20 #include "solver.h"
  21 #include "solverdebug.h"
  22 #include "bitmap.h"
  23 #include "pool.h"
  24 #include "poolarch.h"
  25 #include "util.h"
  26 #include "evr.h"
  27 #include "policy.h"
  28
  29
  30 /*
  31  * create obsoletesmap from solver decisions
  32  *
  33  * for solvables in installed repo:
  34  *   0 - not obsoleted
  35  *   p - one of the packages that obsolete us
  36  * for all others:
  37  *   n - number of packages this package obsoletes
  38  *
  39  */
  40
  41 /* OBSOLETE: use transaction code instead! */
  42
  43 Id *
  44 solver_create_decisions_obsoletesmap(Solver *solv)
  45 {
  46   Pool *pool = solv->pool;
  47   Repo *installed = solv->installed;
  48   Id p, *obsoletesmap = NULL;
  49   int i;
  50   Solvable *s;
  51
  52   obsoletesmap = (Id *)sat_calloc(pool->nsolvables, sizeof(Id));
  53   if (installed)
  54     {
  55       for (i = 0; i < solv->decisionq.count; i++)
  56         {
  57           Id pp, n;
  58           int noobs;
  59
  60           n = solv->decisionq.elements[i];
  61           if (n < 0)
  62             continue;
  63           if (n == SYSTEMSOLVABLE)
  64             continue;
  65           s = pool->solvables + n;
  66           if (s->repo == installed)             /* obsoletes don't count for already installed packages */
  67             continue;
  68           noobs = solv->noobsoletes.size && MAPTST(&solv->noobsoletes, n);
  69           FOR_PROVIDES(p, pp, s->name)
  70             {
  71               Solvable *ps = pool->solvables + p;
  72               if (noobs && (s->name != ps->name || s->evr != ps->evr || s->arch != ps->arch))
  73                 continue;
  74               if (!pool->implicitobsoleteusesprovides && s->name != ps->name)
  75                 continue;
  76               if (pool->obsoleteusescolors && !pool_colormatch(pool, s, ps))
  77                 continue;
  78               if (ps->repo == installed && !obsoletesmap[p])
  79                 {
  80                   obsoletesmap[p] = n;
  81                   obsoletesmap[n]++;
  82                 }
  83             }
  84         }
  85       for (i = 0; i < solv->decisionq.count; i++)
  86         {
  87           Id obs, *obsp;
  88           Id pp, n;
  89
  90           n = solv->decisionq.elements[i];
  91           if (n < 0)
  92             continue;
  93           if (n == SYSTEMSOLVABLE)
  94             continue;
  95           s = pool->solvables + n;
  96           if (s->repo == installed)             /* obsoletes don't count for already installed packages */
  97             continue;
  98           if (!s->obsoletes)
  99             continue;
 100           if (solv->noobsoletes.size && MAPTST(&solv->noobsoletes, n))
 101             continue;
 102           obsp = s->repo->idarraydata + s->obsoletes;
 103           while ((obs = *obsp++) != 0)
 104             {
 105               FOR_PROVIDES(p, pp, obs)
 106                 {
 107                   Solvable *ps = pool->solvables + p;
 108                   if (!pool->obsoleteusesprovides && !pool_match_nevr(pool, ps, obs))
 109                     continue;
 110                   if (pool->obsoleteusescolors && !pool_colormatch(pool, s, ps))
 111                     continue;
 112                   if (pool->solvables[p].repo == installed && !obsoletesmap[p])
 113                     {
 114                       obsoletesmap[p] = n;
 115                       obsoletesmap[n]++;
 116                     }
 117                 }
 118             }
 119         }
 120     }
 121   return obsoletesmap;
 122 }
 123
 124 void
 125 solver_printruleelement(Solver *solv, int type, Rule *r, Id v)
 126 {
 127   Pool *pool = solv->pool;
 128   Solvable *s;
 129   if (v < 0)
 130     {
 131       s = pool->solvables + -v;
 132       POOL_DEBUG(type, "    !%s [%d]", solvable2str(pool, s), -v);
 133     }
 134   else
 135     {
 136       s = pool->solvables + v;
 137       POOL_DEBUG(type, "    %s [%d]", solvable2str(pool, s), v);
 138     }
 139   if (pool->installed && s->repo == pool->installed)
 140     POOL_DEBUG(type, "I");
 141   if (r)
 142     {
 143       if (r->w1 == v)
 144         POOL_DEBUG(type, " (w1)");
 145       if (r->w2 == v)
 146         POOL_DEBUG(type, " (w2)");
 147     }
 148   if (solv->decisionmap[s - pool->solvables] > 0)
 149     POOL_DEBUG(type, " Install.level%d", solv->decisionmap[s - pool->solvables]);
 150   if (solv->decisionmap[s - pool->solvables] < 0)
 151     POOL_DEBUG(type, " Conflict.level%d", -solv->decisionmap[s - pool->solvables]);
 152   POOL_DEBUG(type, "\n");
 153 }
 154
 155
 156 /*
 157  * print rule
 158  */
 159
 160 void
 161 solver_printrule(Solver *solv, int type, Rule *r)
 162 {
 163   Pool *pool = solv->pool;
 164   int i;
 165   Id d, v;
 166
 167   if (r >= solv->rules && r < solv->rules + solv->nrules)   /* r is a solver rule */
 168     POOL_DEBUG(type, "Rule #%d:", (int)(r - solv->rules));
 169   else
 170     POOL_DEBUG(type, "Rule:");                 /* r is any rule */
 171   if (r && r->d < 0)
 172     POOL_DEBUG(type, " (disabled)");
 173   POOL_DEBUG(type, "\n");
 174   d = r->d < 0 ? -r->d - 1 : r->d;
 175   for (i = 0; ; i++)
 176     {
 177       if (i == 0)
 178           /* print direct literal */
 179         v = r->p;
 180       else if (!d)
 181         {
 182           if (i == 2)
 183             break;
 184           /* binary rule --> print w2 as second literal */
 185           v = r->w2;
 186         }
 187       else
 188           /* every other which is in d */
 189         v = solv->pool->whatprovidesdata[d + i - 1];
 190       if (v == ID_NULL)
 191         break;
 192       solver_printruleelement(solv, type, r, v);
 193     }
 194   POOL_DEBUG(type, "    next rules: %d %d\n", r->n1, r->n2);
 195 }
 196
 197 void
 198 solver_printruleclass(Solver *solv, int type, Rule *r)
 199 {
 200   Pool *pool = solv->pool;
 201   Id p = r - solv->rules;
 202   assert(p >= 0);
 203   if (p < solv->learntrules)
 204     if (MAPTST(&solv->weakrulemap, p))
 205       POOL_DEBUG(type, "WEAK ");
 206   if (p >= solv->learntrules)
 207     POOL_DEBUG(type, "LEARNT ");
 208   else if (p >= solv->choicerules && p < solv->choicerules_end)
 209     POOL_DEBUG(type, "CHOICE ");
 210   else if (p >= solv->infarchrules && p < solv->infarchrules_end)
 211     POOL_DEBUG(type, "INFARCH ");
 212   else if (p >= solv->duprules && p < solv->duprules_end)
 213     POOL_DEBUG(type, "DUP ");
 214   else if (p >= solv->jobrules && p < solv->jobrules_end)
 215     POOL_DEBUG(type, "JOB ");
 216   else if (p >= solv->updaterules && p < solv->updaterules_end)
 217     POOL_DEBUG(type, "UPDATE ");
 218   else if (p >= solv->featurerules && p < solv->featurerules_end)
 219     POOL_DEBUG(type, "FEATURE ");
 220   solver_printrule(solv, type, r);
 221 }
 222
 223 void
 224 solver_printproblem(Solver *solv, Id v)
 225 {
 226   Pool *pool = solv->pool;
 227   int i;
 228   Rule *r;
 229   Id *jp;
 230
 231   if (v > 0)
 232     solver_printruleclass(solv, SAT_DEBUG_SOLUTIONS, solv->rules + v);
 233   else
 234     {
 235       v = -(v + 1);
 236       POOL_DEBUG(SAT_DEBUG_SOLUTIONS, "JOB %d\n", v);
 237       jp = solv->ruletojob.elements;
 238       for (i = solv->jobrules, r = solv->rules + i; i < solv->jobrules_end; i++, r++, jp++)
 239         if (*jp == v)
 240           {
 241             POOL_DEBUG(SAT_DEBUG_SOLUTIONS, "- ");
 242             solver_printrule(solv, SAT_DEBUG_SOLUTIONS, r);
 243           }
 244       POOL_DEBUG(SAT_DEBUG_SOLUTIONS, "ENDJOB\n");
 245     }
 246 }
 247
 248 void
 249 solver_printwatches(Solver *solv, int type)
 250 {
 251   Pool *pool = solv->pool;
 252   int counter;
 253
 254   POOL_DEBUG(type, "Watches: \n");
 255   for (counter = -(pool->nsolvables - 1); counter < pool->nsolvables; counter++)
 256     POOL_DEBUG(type, "    solvable [%d] -- rule [%d]\n", counter, solv->watches[counter + pool->nsolvables]);
 257 }
 258
 259 /*
 260  * printdecisions
 261  */
 262
 263 void
 264 solver_printdecisions(Solver *solv)
 265 {
 266   Pool *pool = solv->pool;
 267   Repo *installed = solv->installed;
 268   Id p, type;
 269   int i, j;
 270   Solvable *s;
 271   Queue iq;
 272
 273   IF_POOLDEBUG (SAT_DEBUG_SCHUBI)
 274     {
 275       POOL_DEBUG(SAT_DEBUG_SCHUBI, "----- Decisions -----\n");
 276       for (i = 0; i < solv->decisionq.count; i++)
 277         {
 278           p = solv->decisionq.elements[i];
 279           solver_printruleelement(solv, SAT_DEBUG_SCHUBI, 0, p);
 280         }
 281       POOL_DEBUG(SAT_DEBUG_SCHUBI, "----- Decisions end -----\n");
 282     }
 283
 284   POOL_DEBUG(SAT_DEBUG_RESULT, "\n");
 285   POOL_DEBUG(SAT_DEBUG_RESULT, "transaction:\n");
 286
 287   queue_init(&iq);
 288   for (i = 0; i < solv->trans.steps.count; i++)
 289     {
 290       p = solv->trans.steps.elements[i];
 291       s = pool->solvables + p;
 292       type = transaction_type(&solv->trans, p, SOLVER_TRANSACTION_SHOW_ACTIVE|SOLVER_TRANSACTION_SHOW_ALL|SOLVER_TRANSACTION_SHOW_OBSOLETES|SOLVER_TRANSACTION_SHOW_MULTIINSTALL);
 293       switch(type)
 294         {
 295         case SOLVER_TRANSACTION_MULTIINSTALL:
 296           POOL_DEBUG(SAT_DEBUG_RESULT, "  multi install %s", solvable2str(pool, s));
 297           break;
 298         case SOLVER_TRANSACTION_MULTIREINSTALL:
 299           POOL_DEBUG(SAT_DEBUG_RESULT, "  multi reinstall %s", solvable2str(pool, s));
 300           break;
 301         case SOLVER_TRANSACTION_INSTALL:
 302           POOL_DEBUG(SAT_DEBUG_RESULT, "  install   %s", solvable2str(pool, s));
 303           break;
 304         case SOLVER_TRANSACTION_REINSTALL:
 305           POOL_DEBUG(SAT_DEBUG_RESULT, "  reinstall %s", solvable2str(pool, s));
 306           break;
 307         case SOLVER_TRANSACTION_DOWNGRADE:
 308           POOL_DEBUG(SAT_DEBUG_RESULT, "  downgrade %s", solvable2str(pool, s));
 309           break;
 310         case SOLVER_TRANSACTION_CHANGE:
 311           POOL_DEBUG(SAT_DEBUG_RESULT, "  change    %s", solvable2str(pool, s));
 312           break;
 313         case SOLVER_TRANSACTION_UPGRADE:
 314         case SOLVER_TRANSACTION_OBSOLETES:
 315           POOL_DEBUG(SAT_DEBUG_RESULT, "  upgrade   %s", solvable2str(pool, s));
 316           break;
 317         case SOLVER_TRANSACTION_ERASE:
 318           POOL_DEBUG(SAT_DEBUG_RESULT, "  erase     %s", solvable2str(pool, s));
 319           break;
 320         default:
 321           break;
 322         }
 323       switch(type)
 324         {
 325         case SOLVER_TRANSACTION_INSTALL:
 326         case SOLVER_TRANSACTION_ERASE:
 327           POOL_DEBUG(SAT_DEBUG_RESULT, "\n");
 328           break;
 329         case SOLVER_TRANSACTION_REINSTALL:
 330         case SOLVER_TRANSACTION_DOWNGRADE:
 331         case SOLVER_TRANSACTION_CHANGE:
 332         case SOLVER_TRANSACTION_UPGRADE:
 333         case SOLVER_TRANSACTION_OBSOLETES:
 334           transaction_all_obs_pkgs(&solv->trans, p, &iq);
 335           if (iq.count)
 336             {
 337               POOL_DEBUG(SAT_DEBUG_RESULT, "  (obsoletes");
 338               for (j = 0; j < iq.count; j++)
 339                 POOL_DEBUG(SAT_DEBUG_RESULT, " %s", solvid2str(pool, iq.elements[j]));
 340               POOL_DEBUG(SAT_DEBUG_RESULT, ")");
 341             }
 342           POOL_DEBUG(SAT_DEBUG_RESULT, "\n");
 343           break;
 344         default:
 345           break;
 346         }
 347     }
 348   queue_free(&iq);
 349
 350   POOL_DEBUG(SAT_DEBUG_RESULT, "\n");
 351
 352   if (solv->recommendations.count)
 353     {
 354       POOL_DEBUG(SAT_DEBUG_RESULT, "recommended packages:\n");
 355       for (i = 0; i < solv->recommendations.count; i++)
 356         {
 357           s = pool->solvables + solv->recommendations.elements[i];
 358           if (solv->decisionmap[solv->recommendations.elements[i]] > 0)
 359             {
 360               if (installed && s->repo == installed)
 361                 POOL_DEBUG(SAT_DEBUG_RESULT, "  %s (installed)\n", solvable2str(pool, s));
 362               else
 363                 POOL_DEBUG(SAT_DEBUG_RESULT, "  %s (selected)\n", solvable2str(pool, s));
 364             }
 365           else
 366             POOL_DEBUG(SAT_DEBUG_RESULT, "  %s\n", solvable2str(pool, s));
 367         }
 368       POOL_DEBUG(SAT_DEBUG_RESULT, "\n");
 369     }
 370
 371   if (solv->suggestions.count)
 372     {
 373       POOL_DEBUG(SAT_DEBUG_RESULT, "suggested packages:\n");
 374       for (i = 0; i < solv->suggestions.count; i++)
 375         {
 376           s = pool->solvables + solv->suggestions.elements[i];
 377           if (solv->decisionmap[solv->suggestions.elements[i]] > 0)
 378             {
 379               if (installed && s->repo == installed)
 380                 POOL_DEBUG(SAT_DEBUG_RESULT, "  %s (installed)\n", solvable2str(pool, s));
 381               else
 382                 POOL_DEBUG(SAT_DEBUG_RESULT, "  %s (selected)\n", solvable2str(pool, s));
 383             }
 384           else
 385             POOL_DEBUG(SAT_DEBUG_RESULT, "  %s\n", solvable2str(pool, s));
 386         }
 387       POOL_DEBUG(SAT_DEBUG_RESULT, "\n");
 388     }
 389   if (solv->orphaned.count)
 390     {
 391       POOL_DEBUG(SAT_DEBUG_RESULT, "orphaned packages:\n");
 392       for (i = 0; i < solv->orphaned.count; i++)
 393         {
 394           s = pool->solvables + solv->orphaned.elements[i];
 395           if (solv->decisionmap[solv->orphaned.elements[i]] > 0)
 396             POOL_DEBUG(SAT_DEBUG_RESULT, "  %s (kept)\n", solvable2str(pool, s));
 397           else
 398             POOL_DEBUG(SAT_DEBUG_RESULT, "  %s (erased)\n", solvable2str(pool, s));
 399         }
 400       POOL_DEBUG(SAT_DEBUG_RESULT, "\n");
 401     }
 402 }
 403
 404 static inline
 405 const char *id2strnone(Pool *pool, Id id)
 406 {
 407   return !id || id == 1 ? "(none)" : id2str(pool, id);
 408 }
 409
 410 void
 411 solver_printtransaction(Solver *solv)
 412 {
 413   Transaction *trans = &solv->trans;
 414   Pool *pool = trans->pool;
 415   Queue classes, pkgs;
 416   int i, j, mode, l, linel;
 417   char line[76];
 418   const char *n;
 419
 420   queue_init(&classes);
 421   queue_init(&pkgs);
 422   mode = 0;
 423   transaction_classify(trans, mode, &classes);
 424   for (i = 0; i < classes.count; i += 4)
 425     {
 426       Id class = classes.elements[i];
 427       Id cnt = classes.elements[i + 1];
 428       switch(class)
 429         {
 430         case SOLVER_TRANSACTION_ERASE:
 431           POOL_DEBUG(SAT_DEBUG_RESULT, "%d erased packages:\n", cnt);
 432           break;
 433         case SOLVER_TRANSACTION_INSTALL:
 434           POOL_DEBUG(SAT_DEBUG_RESULT, "%d installed packages:\n", cnt);
 435           break;
 436         case SOLVER_TRANSACTION_REINSTALLED:
 437           POOL_DEBUG(SAT_DEBUG_RESULT, "%d reinstalled packages:\n", cnt);
 438           break;
 439         case SOLVER_TRANSACTION_DOWNGRADED:
 440           POOL_DEBUG(SAT_DEBUG_RESULT, "%d downgraded packages:\n", cnt);
 441           break;
 442         case SOLVER_TRANSACTION_CHANGED:
 443           POOL_DEBUG(SAT_DEBUG_RESULT, "%d changed packages:\n", cnt);
 444           break;
 445         case SOLVER_TRANSACTION_UPGRADED:
 446           POOL_DEBUG(SAT_DEBUG_RESULT, "%d upgraded packages:\n", cnt);
 447           break;
 448         case SOLVER_TRANSACTION_VENDORCHANGE:
 449           POOL_DEBUG(SAT_DEBUG_RESULT, "%d vendor changes from '%s' to '%s':\n", cnt, id2strnone(pool, classes.elements[i + 2]), id2strnone(pool, classes.elements[i + 3]));
 450           break;
 451         case SOLVER_TRANSACTION_ARCHCHANGE:
 452           POOL_DEBUG(SAT_DEBUG_RESULT, "%d arch changes from %s to %s:\n", cnt, id2str(pool, classes.elements[i + 2]), id2str(pool, classes.elements[i + 3]));
 453           break;
 454         default:
 455           class = SOLVER_TRANSACTION_IGNORE;
 456           break;
 457         }
 458       if (class == SOLVER_TRANSACTION_IGNORE)
 459         continue;
 460       transaction_classify_pkgs(trans, mode, class, classes.elements[i + 2], classes.elements[i + 3], &pkgs);
 461       *line = 0;
 462       linel = 0;
 463       for (j = 0; j < pkgs.count; j++)
 464         {
 465           Id p = pkgs.elements[j];
 466           Solvable *s = pool->solvables + p;
 467           Solvable *s2;
 468
 469           switch(class)
 470             {
 471             case SOLVER_TRANSACTION_DOWNGRADED:
 472             case SOLVER_TRANSACTION_UPGRADED:
 473               s2 = pool->solvables + transaction_obs_pkg(trans, p);
 474               POOL_DEBUG(SAT_DEBUG_RESULT, "  - %s -> %s\n", solvable2str(pool, s), solvable2str(pool, s2));
 475               break;
 476             case SOLVER_TRANSACTION_VENDORCHANGE:
 477             case SOLVER_TRANSACTION_ARCHCHANGE:
 478               n = id2str(pool, s->name);
 479               l = strlen(n);
 480               if (l + linel > sizeof(line) - 3)
 481                 {
 482                   if (*line)
 483                     POOL_DEBUG(SAT_DEBUG_RESULT, "    %s\n", line);
 484                   *line = 0;
 485                   linel = 0;
 486                 }
 487               if (l + linel > sizeof(line) - 3)
 488                 POOL_DEBUG(SAT_DEBUG_RESULT, "    %s\n", n);
 489               else
 490                 {
 491                   if (*line)
 492                     {
 493                       strcpy(line + linel, ", ");
 494                       linel += 2;
 495                     }
 496                   strcpy(line + linel, n);
 497                   linel += l;
 498                 }
 499               break;
 500             default:
 501               POOL_DEBUG(SAT_DEBUG_RESULT, "  - %s\n", solvable2str(pool, s));
 502               break;
 503             }
 504         }
 505       if (*line)
 506         POOL_DEBUG(SAT_DEBUG_RESULT, "    %s\n", line);
 507       POOL_DEBUG(SAT_DEBUG_RESULT, "\n");
 508     }
 509   queue_free(&classes);
 510   queue_free(&pkgs);
 511 }
 512
 513 void
 514 solver_printprobleminfo(Solver *solv, Id problem)
 515 {
 516   Pool *pool = solv->pool;
 517   Id probr;
 518   Id dep, source, target;
 519
 520   probr = solver_findproblemrule(solv, problem);
 521   switch (solver_ruleinfo(solv, probr, &source, &target, &dep))
 522     {
 523     case SOLVER_RULE_DISTUPGRADE:
 524       POOL_DEBUG(SAT_DEBUG_RESULT, "%s does not belong to a distupgrade repository\n", solvid2str(pool, source));
 525       return;
 526     case SOLVER_RULE_INFARCH:
 527       POOL_DEBUG(SAT_DEBUG_RESULT, "%s has inferior architecture\n", solvid2str(pool, source));
 528       return;
 529     case SOLVER_RULE_UPDATE:
 530       POOL_DEBUG(SAT_DEBUG_RESULT, "problem with installed package %s\n", solvid2str(pool, source));
 531       return;
 532     case SOLVER_RULE_JOB:
 533       POOL_DEBUG(SAT_DEBUG_RESULT, "conflicting requests\n");
 534       return;
 535     case SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP:
 536       POOL_DEBUG(SAT_DEBUG_RESULT, "nothing provides requested %s\n", dep2str(pool, dep));
 537       return;
 538     case SOLVER_RULE_RPM:
 539       POOL_DEBUG(SAT_DEBUG_RESULT, "some dependency problem\n");
 540       return;
 541     case SOLVER_RULE_RPM_NOT_INSTALLABLE:
 542       POOL_DEBUG(SAT_DEBUG_RESULT, "package %s is not installable\n", solvid2str(pool, source));
 543       return;
 544     case SOLVER_RULE_RPM_NOTHING_PROVIDES_DEP:
 545       POOL_DEBUG(SAT_DEBUG_RESULT, "nothing provides %s needed by %s\n", dep2str(pool, dep), solvid2str(pool, source));
 546       return;
 547     case SOLVER_RULE_RPM_SAME_NAME:
 548       POOL_DEBUG(SAT_DEBUG_RESULT, "cannot install both %s and %s\n", solvid2str(pool, source), solvid2str(pool, target));
 549       return;
 550     case SOLVER_RULE_RPM_PACKAGE_CONFLICT:
 551       POOL_DEBUG(SAT_DEBUG_RESULT, "package %s conflicts with %s provided by %s\n", solvid2str(pool, source), dep2str(pool, dep), solvid2str(pool, target));
 552       return;
 553     case SOLVER_RULE_RPM_PACKAGE_OBSOLETES:
 554       POOL_DEBUG(SAT_DEBUG_RESULT, "package %s obsoletes %s provided by %s\n", solvid2str(pool, source), dep2str(pool, dep), solvid2str(pool, target));
 555       return;
 556     case SOLVER_RULE_RPM_IMPLICIT_OBSOLETES:
 557       POOL_DEBUG(SAT_DEBUG_RESULT, "package %s implicitely obsoletes %s provided by %s\n", solvid2str(pool, source), dep2str(pool, dep), solvid2str(pool, target));
 558       return;
 559     case SOLVER_RULE_RPM_PACKAGE_REQUIRES:
 560       POOL_DEBUG(SAT_DEBUG_RESULT, "package %s requires %s, but none of the providers can be installed\n", solvid2str(pool, source), dep2str(pool, dep));
 561       return;
 562     case SOLVER_RULE_RPM_SELF_CONFLICT:
 563       POOL_DEBUG(SAT_DEBUG_RESULT, "package %s conflicts with %s provided by itself\n", solvid2str(pool, source), dep2str(pool, dep));
 564       return;
 565     case SOLVER_RULE_UNKNOWN:
 566     case SOLVER_RULE_FEATURE:
 567     case SOLVER_RULE_LEARNT:
 568     case SOLVER_RULE_CHOICE:
 569       POOL_DEBUG(SAT_DEBUG_RESULT, "bad rule type\n");
 570       return;
 571     }
 572 }
 573
 574 void
 575 solver_printsolution(Solver *solv, Id problem, Id solution)
 576 {
 577   Pool *pool = solv->pool;
 578   Id p, rp, element, how, what, select;
 579   Solvable *s, *sd;
 580
 581   element = 0;
 582   while ((element = solver_next_solutionelement(solv, problem, solution, element, &p, &rp)) != 0)
 583     {
 584       if (p == SOLVER_SOLUTION_JOB)
 585         {
 586           /* job, rp is index into job queue */
 587           how = solv->job.elements[rp - 1];
 588           what = solv->job.elements[rp];
 589           select = how & SOLVER_SELECTMASK;
 590           switch (how & SOLVER_JOBMASK)
 591             {
 592             case SOLVER_INSTALL:
 593               if (select == SOLVER_SOLVABLE && solv->installed && pool->solvables[what].repo == solv->installed)
 594                 POOL_DEBUG(SAT_DEBUG_RESULT, "  - do not keep %s installed\n", solvid2str(pool, what));
 595               else if (select == SOLVER_SOLVABLE_PROVIDES)
 596                 POOL_DEBUG(SAT_DEBUG_RESULT, "  - do not install a solvable %s\n", solver_select2str(solv, select, what));
 597               else
 598                 POOL_DEBUG(SAT_DEBUG_RESULT, "  - do not install %s\n", solver_select2str(solv, select, what));
 599               break;
 600             case SOLVER_ERASE:
 601               if (select == SOLVER_SOLVABLE && !(solv->installed && pool->solvables[what].repo == solv->installed))
 602                 POOL_DEBUG(SAT_DEBUG_RESULT, "  - do not forbid installation of %s\n", solvid2str(pool, what));
 603               else if (select == SOLVER_SOLVABLE_PROVIDES)
 604                 POOL_DEBUG(SAT_DEBUG_RESULT, "  - do not deinstall all solvables %s\n", solver_select2str(solv, select, what));
 605               else
 606                 POOL_DEBUG(SAT_DEBUG_RESULT, "  - do not deinstall %s\n", solver_select2str(solv, select, what));
 607               break;
 608             case SOLVER_UPDATE:
 609               POOL_DEBUG(SAT_DEBUG_RESULT, "  - do not install most recent version of %s\n", solver_select2str(solv, select, what));
 610               break;
 611             case SOLVER_LOCK:
 612               POOL_DEBUG(SAT_DEBUG_RESULT, "  - do not lock %s\n", solver_select2str(solv, select, what));
 613               break;
 614             default:
 615               POOL_DEBUG(SAT_DEBUG_RESULT, "  - do something different\n");
 616               break;
 617             }
 618         }
 619       else if (p == SOLVER_SOLUTION_INFARCH)
 620         {
 621           s = pool->solvables + rp;
 622           if (solv->installed && s->repo == solv->installed)
 623             POOL_DEBUG(SAT_DEBUG_RESULT, "  - keep %s despite the inferior architecture\n", solvable2str(pool, s));
 624           else
 625             POOL_DEBUG(SAT_DEBUG_RESULT, "  - install %s despite the inferior architecture\n", solvable2str(pool, s));
 626         }
 627       else if (p == SOLVER_SOLUTION_DISTUPGRADE)
 628         {
 629           s = pool->solvables + rp;
 630           if (solv->installed && s->repo == solv->installed)
 631             POOL_DEBUG(SAT_DEBUG_RESULT, "  - keep obsolete %s\n", solvable2str(pool, s));
 632           else
 633             POOL_DEBUG(SAT_DEBUG_RESULT, "  - install %s from excluded repository\n", solvable2str(pool, s));
 634         }
 635       else
 636         {
 637           /* policy, replace p with rp */
 638           s = pool->solvables + p;
 639           sd = rp ? pool->solvables + rp : 0;
 640           if (s == sd && solv->distupgrade)
 641             {
 642               POOL_DEBUG(SAT_DEBUG_RESULT, "  - keep obsolete %s\n", solvable2str(pool, s));
 643             }
 644           else if (sd)
 645             {
 646               int gotone = 0;
 647               if (!solv->allowdowngrade && evrcmp(pool, s->evr, sd->evr, EVRCMP_MATCH_RELEASE) > 0)
 648                 {
 649                   POOL_DEBUG(SAT_DEBUG_RESULT, "  - allow downgrade of %s to %s\n", solvable2str(pool, s), solvable2str(pool, sd));
 650                   gotone = 1;
 651                 }
 652               if (!solv->allowarchchange && s->name == sd->name && s->arch != sd->arch && policy_illegal_archchange(solv, s, sd))
 653                 {
 654                   POOL_DEBUG(SAT_DEBUG_RESULT, "  - allow architecture change of %s to %s\n", solvable2str(pool, s), solvable2str(pool, sd));
 655                   gotone = 1;
 656                 }
 657               if (!solv->allowvendorchange && s->name == sd->name && s->vendor != sd->vendor && policy_illegal_vendorchange(solv, s, sd))
 658                 {
 659                   if (sd->vendor)
 660                     POOL_DEBUG(SAT_DEBUG_RESULT, "  - allow vendor change from '%s' (%s) to '%s' (%s)\n", id2str(pool, s->vendor), solvable2str(pool, s), id2str(pool, sd->vendor), solvable2str(pool, sd));
 661                   else
 662                     POOL_DEBUG(SAT_DEBUG_RESULT, "  - allow vendor change from '%s' (%s) to no vendor (%s)\n", id2str(pool, s->vendor), solvable2str(pool, s), solvable2str(pool, sd));
 663                   gotone = 1;
 664                 }
 665               if (!gotone)
 666                 POOL_DEBUG(SAT_DEBUG_RESULT, "  - allow replacement of %s with %s\n", solvable2str(pool, s), solvable2str(pool, sd));
 667             }
 668           else
 669             {
 670               POOL_DEBUG(SAT_DEBUG_RESULT, "  - allow deinstallation of %s\n", solvable2str(pool, s));
 671             }
 672
 673         }
 674     }
 675 }
 676
 677 void
 678 solver_printallsolutions(Solver *solv)
 679 {
 680   Pool *pool = solv->pool;
 681   int pcnt;
 682   Id problem, solution;
 683
 684   POOL_DEBUG(SAT_DEBUG_RESULT, "Encountered problems! Here are the solutions:\n\n");
 685   pcnt = 0;
 686   problem = 0;
 687   while ((problem = solver_next_problem(solv, problem)) != 0)
 688     {
 689       pcnt++;
 690       POOL_DEBUG(SAT_DEBUG_RESULT, "Problem %d:\n", pcnt);
 691       POOL_DEBUG(SAT_DEBUG_RESULT, "====================================\n");
 692       solver_printprobleminfo(solv, problem);
 693       POOL_DEBUG(SAT_DEBUG_RESULT, "\n");
 694       solution = 0;
 695       while ((solution = solver_next_solution(solv, problem, solution)) != 0)
 696         {
 697           solver_printsolution(solv, problem, solution);
 698           POOL_DEBUG(SAT_DEBUG_RESULT, "\n");
 699         }
 700     }
 701 }
 702
 703 void
 704 solver_printtrivial(Solver *solv)
 705 {
 706   Pool *pool = solv->pool;
 707   Queue in, out;
 708   Id p;
 709   const char *n;
 710   Solvable *s;
 711   int i;
 712
 713   queue_init(&in);
 714   for (p = 1, s = pool->solvables + p; p < solv->pool->nsolvables; p++, s++)
 715     {
 716       n = id2str(pool, s->name);
 717       if (strncmp(n, "patch:", 6) != 0 && strncmp(n, "pattern:", 8) != 0)
 718         continue;
 719       queue_push(&in, p);
 720     }
 721   if (!in.count)
 722     {
 723       queue_free(&in);
 724       return;
 725     }
 726   queue_init(&out);
 727   solver_trivial_installable(solv, &in, &out);
 728   POOL_DEBUG(SAT_DEBUG_RESULT, "trivial installable status:\n");
 729   for (i = 0; i < in.count; i++)
 730     POOL_DEBUG(SAT_DEBUG_RESULT, "  %s: %d\n", solvid2str(pool, in.elements[i]), out.elements[i]);
 731   POOL_DEBUG(SAT_DEBUG_RESULT, "\n");
 732   queue_free(&in);
 733   queue_free(&out);
 734 }
 735
 736 const char *
 737 solver_select2str(Solver *solv, Id select, Id what)
 738 {
 739   Pool *pool = solv->pool;
 740   const char *s;
 741   char *b;
 742   if (select == SOLVER_SOLVABLE)
 743     return solvid2str(pool, what);
 744   if (select == SOLVER_SOLVABLE_NAME)
 745     return dep2str(pool, what);
 746   if (select == SOLVER_SOLVABLE_PROVIDES)
 747     {
 748       s = dep2str(pool, what);
 749       b = pool_alloctmpspace(pool, 11 + strlen(s));
 750       sprintf(b, "providing %s", s);
 751       return b;
 752     }
 753   if (select == SOLVER_SOLVABLE_ONE_OF)
 754     {
 755       Id p;
 756       char *b2;
 757       b = "";
 758       while ((p = pool->whatprovidesdata[what++]) != 0)
 759         {
 760           s = solvid2str(pool, p);
 761           b2 = pool_alloctmpspace(pool, strlen(b) + strlen(s) + 3);
 762           sprintf(b2, "%s, %s", b, s);
 763           b = b2;
 764         }
 765       return *b ? b + 2 : "nothing";
 766     }
 767   return "unknown job select";
 768 }