src/cleandeps.c

   1 /*
   2  * Copyright (c) 2017, SUSE Inc.
   3  *
   4  * This program is licensed under the BSD license, read LICENSE.BSD
   5  * for further information
   6  */
   7
   8 /*
   9  * cleandeps.c
  10  *
  11  * code to find and erase unneeded packages
  12  */
  13
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <unistd.h>
  17 #include <string.h>
  18
  19 #include "solver.h"
  20 #include "solverdebug.h"
  21 #include "solver_private.h"
  22 #include "bitmap.h"
  23 #include "pool.h"
  24 #include "util.h"
  25 #include "policy.h"
  26 #include "cplxdeps.h"
  27
  28 #undef CLEANDEPSDEBUG
  29
  30 /*
  31  * This functions collects all packages that are looked at
  32  * when a dependency is checked. We need it to "pin" installed
  33  * packages when removing a supplemented package in createcleandepsmap.
  34  * Here's an not uncommon example:
  35  *   A contains "Supplements: packageand(B, C)"
  36  *   B contains "Requires: A"
  37  * Now if we remove C, the supplements is no longer true,
  38  * thus we also remove A. Without the dep_pkgcheck function, we
  39  * would now also remove B, but this is wrong, as adding back
  40  * C doesn't make the supplements true again. Thus we "pin" B
  41  * when we remove A.
  42  * There's probably a better way to do this, but I haven't come
  43  * up with it yet ;)
  44  */
  45 static void
  46 dep_pkgcheck_slow(Solver *solv, Id dep, Map *m, Queue *q)
  47 {
  48   Pool *pool = solv->pool;
  49   Id p, pp;
  50
  51   if (ISRELDEP(dep))
  52     {
  53       Reldep *rd = GETRELDEP(pool, dep);
  54       if (rd->flags >= 8)
  55         {
  56           if (rd->flags == REL_AND)
  57             {
  58               dep_pkgcheck_slow(solv, rd->name, m, q);
  59               dep_pkgcheck_slow(solv, rd->evr, m, q);
  60               return;
  61             }
  62           if (rd->flags == REL_COND || rd->flags == REL_UNLESS)
  63             {
  64               dep_pkgcheck_slow(solv, rd->name, m, q);
  65               if (ISRELDEP(rd->evr))
  66                 {
  67                   Reldep *rd2 = GETRELDEP(pool, rd->evr);
  68                   if (rd2->flags == REL_ELSE)
  69                     dep_pkgcheck_slow(solv, rd2->evr, m, q);
  70                 }
  71               return;
  72             }
  73           if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_SPLITPROVIDES)
  74             return;
  75         }
  76     }
  77   FOR_PROVIDES(p, pp, dep)
  78     if (!m || MAPTST(m, p))
  79       queue_push(q, p);
  80 }
  81
  82 static inline void
  83 dep_pkgcheck(Solver *solv, Id dep, Map *m, Queue *q)
  84 {
  85   Pool *pool = solv->pool;
  86   Id p, pp;
  87
  88   if (!ISSIMPLEDEP(pool, dep))
  89     {
  90       dep_pkgcheck_slow(solv, dep, m, q);
  91       return;
  92     }
  93   FOR_PROVIDES(p, pp, dep)
  94     if (!m || MAPTST(m, p))
  95       queue_push(q, p);
  96 }
  97
  98 static int
  99 check_xsupp(Solver *solv, Queue *depq, Id dep)
 100 {
 101   Pool *pool = solv->pool;
 102   Id p, pp;
 103
 104   if (ISRELDEP(dep))
 105     {
 106       Reldep *rd = GETRELDEP(pool, dep);
 107       if (rd->flags >= 8)
 108         {
 109           if (rd->flags == REL_AND)
 110             {
 111               if (!check_xsupp(solv, depq, rd->name))
 112                 return 0;
 113               return check_xsupp(solv, depq, rd->evr);
 114             }
 115           if (rd->flags == REL_OR)
 116             {
 117               if (check_xsupp(solv, depq, rd->name))
 118                 return 1;
 119               return check_xsupp(solv, depq, rd->evr);
 120             }
 121           if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_SPLITPROVIDES)
 122             return 0;
 123           if (depq && rd->flags == REL_NAMESPACE)
 124             {
 125               int i;
 126               for (i = 0; i < depq->count; i++)
 127                 if (depq->elements[i] == dep || depq->elements[i] == rd->name)
 128                  return 1;
 129             }
 130         }
 131     }
 132   FOR_PROVIDES(p, pp, dep)
 133     if (p == SYSTEMSOLVABLE || pool->solvables[p].repo == solv->installed)
 134       return 1;
 135   return 0;
 136 }
 137
 138 struct trj_data {
 139   Queue *edges;
 140   Id *low;
 141   Id idx;
 142   Id nstack;
 143   Id firstidx;
 144 };
 145
 146 /* Tarjan's SCC algorithm, slightly modifed */
 147 static void
 148 trj_visit(struct trj_data *trj, Id node)
 149 {
 150   Id *low = trj->low;
 151   Queue *edges = trj->edges;
 152   Id nnode, myidx, stackstart;
 153   int i;
 154
 155   low[node] = myidx = trj->idx++;
 156   low[(stackstart = trj->nstack++)] = node;
 157   for (i = edges->elements[node]; (nnode = edges->elements[i]) != 0; i++)
 158     {
 159       Id l = low[nnode];
 160       if (!l)
 161         {
 162           if (!edges->elements[edges->elements[nnode]])
 163             {
 164               trj->idx++;
 165               low[nnode] = -1;
 166               continue;
 167             }
 168           trj_visit(trj, nnode);
 169           l = low[nnode];
 170         }
 171       if (l < 0)
 172         continue;
 173       if (l < trj->firstidx)
 174         {
 175           int k;
 176           for (k = l; low[low[k]] == l; k++)
 177             low[low[k]] = -1;
 178         }
 179       else if (l < low[node])
 180         low[node] = l;
 181     }
 182   if (low[node] == myidx)
 183     {
 184       if (myidx != trj->firstidx)
 185         myidx = -1;
 186       for (i = stackstart; i < trj->nstack; i++)
 187         low[low[i]] = myidx;
 188       trj->nstack = stackstart;
 189     }
 190 }
 191
 192 #ifdef ENABLE_COMPLEX_DEPS
 193 static void
 194 complex_filter_unneeded(Pool *pool, Id ip, Id req, Queue *edges, Map *cleandepsmap, Queue *unneededq)
 195 {
 196   int i, j;
 197   Queue dq;
 198   Id p;
 199
 200   queue_init(&dq);
 201   i = pool_normalize_complex_dep(pool, req, &dq, CPLXDEPS_EXPAND);
 202   if (i == 0 || i == 1)
 203     {
 204       queue_free(&dq);
 205       return;
 206     }
 207   for (i = 0; i < dq.count; i++)
 208     {
 209       for (; (p = dq.elements[i]) != 0; i++)
 210         {
 211           if (p < 0)
 212             {
 213               if (pool->solvables[-p].repo != pool->installed)
 214                 break;
 215               continue;
 216             }
 217           if (p == ip || pool->solvables[p].repo != pool->installed || !MAPTST(cleandepsmap, p - pool->installed->start))
 218             continue;
 219           for (j = 0; j < unneededq->count; j++)
 220             if (p == unneededq->elements[j])
 221               {
 222                 if (edges->elements[edges->count - 1] != j + 1)
 223                   queue_push(edges, j + 1);
 224                 break;
 225               }
 226         }
 227       while (dq.elements[i])
 228         i++;
 229     }
 230   queue_free(&dq);
 231 }
 232 #endif
 233
 234
 235 static void
 236 filter_unneeded(Solver *solv, Queue *unneededq, Map *unneededmap, int justone)
 237 {
 238   Pool *pool = solv->pool;
 239   Repo *installed = solv->installed;
 240   Queue edges;
 241   Id *nrequires;
 242   Map m, installedm;
 243   int i, j, pass, count = unneededq->count;
 244   Id *low;
 245
 246   if (unneededq->count < 2)
 247     return;
 248   map_init(&m, 0);
 249   if (!unneededmap)
 250     {
 251       unneededmap = &m;
 252       map_grow(unneededmap, installed->end - installed->start);
 253       for (i = 0; i < count; i++)
 254         MAPSET(unneededmap, unneededq->elements[i] - installed->start);
 255     }
 256   map_init(&installedm, pool->nsolvables);
 257   for (i = installed->start; i < installed->end; i++)
 258     if (pool->solvables[i].repo == installed)
 259       MAPSET(&installedm, i);
 260
 261   nrequires = solv_calloc(count, sizeof(Id));
 262   queue_init(&edges);
 263   queue_prealloc(&edges, count * 4 + 10);       /* pre-size */
 264
 265   /*
 266    * Go through the solvables in the nodes queue and create edges for
 267    * all requires/recommends/supplements between the nodes.
 268    * The edges are stored in the edges queue, we add 1 to the node
 269    * index so that nodes in the edges queue are != 0 and we can
 270    * terminate the edge list with 0.
 271    * Thus for node element 5, the edges are stored starting at
 272    * edges.elements[6] and are 0-terminated.
 273    */
 274   /* leave first element zero to make things easier */
 275   /* also add trailing zero */
 276   queue_insertn(&edges, 0, 1 + count + 1, 0);
 277
 278   /* first requires and recommends */
 279   for (i = 0; i < count; i++)
 280     {
 281       Solvable *s = pool->solvables + unneededq->elements[i];
 282       int oldcount = edges.count;
 283       edges.elements[i + 1] = oldcount;
 284       for (pass = 0; pass < 2; pass++)
 285         {
 286           unsigned int off = pass == 0 ? s->requires : s->recommends;
 287           Id p, pp, dep, *dp;
 288           if (off)
 289             for (dp = s->repo->idarraydata + off; (dep = *dp) != 0; dp++)
 290               {
 291 #ifdef ENABLE_COMPLEX_DEPS
 292                 if (pool_is_complex_dep(pool, dep))
 293                   {
 294                     complex_filter_unneeded(pool, s - pool->solvables, dep, &edges, unneededmap, unneededq);
 295                     continue;
 296                   }
 297 #endif
 298                 if (justone)
 299                   {
 300                     int count = 0;
 301                     FOR_PROVIDES(p, pp, dep)
 302                       {
 303                         Solvable *sp = pool->solvables + p;
 304                         if (s == sp || sp->repo != installed)
 305                           continue;
 306                         count++;
 307                       }
 308                     if (count != 1)
 309                       continue;
 310                   }
 311                 FOR_PROVIDES(p, pp, dep)
 312                   {
 313                     Solvable *sp = pool->solvables + p;
 314                     if (s == sp || sp->repo != installed || !MAPTST(unneededmap, p - installed->start))
 315                       continue;
 316                     for (j = 0; j < count; j++)
 317                       if (p == unneededq->elements[j])
 318                         {
 319                           if (edges.elements[edges.count - 1] != j + 1)
 320                             queue_push(&edges, j + 1);
 321                         }
 322                   }
 323               }
 324           if (pass == 0)
 325             nrequires[i] = edges.count - oldcount;
 326         }
 327       queue_push(&edges, 0);
 328     }
 329 #if 0
 330   printf("requires + recommends\n");
 331   for (i = 0; i < count; i++)
 332     {
 333       int j;
 334       printf("  %s (%d requires):\n", pool_solvid2str(pool, unneededq->elements[i]), nrequires[i]);
 335       for (j = edges.elements[i + 1]; edges.elements[j]; j++)
 336         printf("    - %s\n", pool_solvid2str(pool, unneededq->elements[edges.elements[j] - 1]));
 337     }
 338 #endif
 339
 340   /* then add supplements */
 341   for (i = 0; i < count; i++)
 342     {
 343       Solvable *s = pool->solvables + unneededq->elements[i];
 344       if (s->supplements)
 345         {
 346           Id *dp;
 347           int k;
 348           for (dp = s->repo->idarraydata + s->supplements; *dp; dp++)
 349             if (solver_dep_possible(solv, *dp, &installedm))
 350               {
 351                 Queue iq;
 352                 Id iqbuf[16];
 353                 queue_init_buffer(&iq, iqbuf, sizeof(iqbuf)/sizeof(*iqbuf));
 354                 dep_pkgcheck(solv, *dp, 0, &iq);
 355                 if (justone && iq.count != 1)
 356                   {
 357                     queue_free(&iq);
 358                     continue;
 359                   }
 360                 for (k = 0; k < iq.count; k++)
 361                   {
 362                     Id p = iq.elements[k];
 363                     Solvable *sp = pool->solvables + p;
 364                     if (p == unneededq->elements[i] || sp->repo != installed || !MAPTST(unneededmap, p - installed->start))
 365                       continue;
 366                     for (j = 0; j < count; j++)
 367                       if (p == unneededq->elements[j])
 368                         break;
 369                     /* now add edge from j + 1 to i + 1 */
 370                     queue_insert(&edges, edges.elements[j + 1] + nrequires[j], i + 1);
 371                     /* addapt following edge pointers */
 372                     for (j = j + 2; j < count + 1; j++)
 373                       edges.elements[j]++;
 374                   }
 375                 queue_free(&iq);
 376               }
 377         }
 378     }
 379 #if 0
 380   /* print result */
 381   printf("+ supplements\n");
 382   for (i = 0; i < count; i++)
 383     {
 384       int j;
 385       printf("  %s (%d requires):\n", pool_solvid2str(pool, unneededq->elements[i]), nrequires[i]);
 386       for (j = edges.elements[i + 1]; edges.elements[j]; j++)
 387         printf("    - %s\n", pool_solvid2str(pool, unneededq->elements[edges.elements[j] - 1]));
 388     }
 389 #endif
 390   map_free(&installedm);
 391
 392   /* now run SCC algo two times, first with requires+recommends+supplements,
 393    * then again without the requires. We run it the second time to get rid
 394    * of packages that got dragged in via recommends/supplements */
 395   /*
 396    * low will contain the result of the SCC search.
 397    * it must be of at least size 2 * (count + 1) and
 398    * must be zero initialized.
 399    * The layout is:
 400    *    0  low low ... low stack stack ...stack 0
 401    *            count              count
 402    */
 403   low = solv_calloc(count + 1, 2 * sizeof(Id));
 404   for (pass = 0; pass < 2; pass++)
 405     {
 406       struct trj_data trj;
 407       if (pass)
 408         {
 409           memset(low, 0, (count + 1) * (2 * sizeof(Id)));
 410           for (i = 0; i < count; i++)
 411             {
 412               edges.elements[i + 1] += nrequires[i];
 413               if (!unneededq->elements[i])
 414                 low[i + 1] = -1;        /* ignore this node */
 415             }
 416         }
 417       trj.edges = &edges;
 418       trj.low = low;
 419       trj.idx = count + 1;      /* stack starts here */
 420       for (i = 1; i <= count; i++)
 421         {
 422           if (low[i])
 423             continue;
 424           if (edges.elements[edges.elements[i]])
 425             {
 426               trj.firstidx = trj.nstack = trj.idx;
 427               trj_visit(&trj, i);
 428             }
 429           else
 430             {
 431               Id myidx = trj.idx++;
 432               low[i] = myidx;
 433               low[myidx] = i;
 434             }
 435         }
 436       /* prune packages */
 437       for (i = 0; i < count; i++)
 438         if (low[i + 1] <= 0)
 439           unneededq->elements[i] = 0;
 440     }
 441   solv_free(low);
 442   solv_free(nrequires);
 443   queue_free(&edges);
 444
 445   /* finally remove all pruned entries from unneededq */
 446   for (i = j = 0; i < count; i++)
 447     if (unneededq->elements[i])
 448       unneededq->elements[j++] = unneededq->elements[i];
 449   queue_truncate(unneededq, j);
 450   map_free(&m);
 451 }
 452
 453
 454 #ifdef ENABLE_COMPLEX_DEPS
 455 static void
 456 complex_cleandeps_remove(Pool *pool, Id ip, Id req, Map *im, Map *installedm, Queue *iq)
 457 {
 458   int i;
 459   Queue dq;
 460   Id p;
 461
 462   queue_init(&dq);
 463   i = pool_normalize_complex_dep(pool, req, &dq, CPLXDEPS_EXPAND);
 464   if (i == 0 || i == 1)
 465     {
 466       queue_free(&dq);
 467       return;
 468     }
 469   for (i = 0; i < dq.count; i++)
 470     {
 471       for (; (p = dq.elements[i]) != 0; i++)
 472         {
 473           if (p < 0)
 474             {
 475               if (!MAPTST(installedm, -p))
 476                 break;
 477               continue;
 478             }
 479           if (p != SYSTEMSOLVABLE && MAPTST(im, p))
 480             {
 481 #ifdef CLEANDEPSDEBUG
 482               printf("%s requires/recommends %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
 483 #endif
 484               queue_push(iq, p);
 485             }
 486         }
 487       while (dq.elements[i])
 488         i++;
 489     }
 490   queue_free(&dq);
 491 }
 492
 493 static void
 494 complex_cleandeps_addback(Pool *pool, Id ip, Id req, Map *im, Map *installedm, Queue *iq, Map *userinstalled)
 495 {
 496   int i, blk;
 497   Queue dq;
 498   Id p;
 499
 500   queue_init(&dq);
 501   i = pool_normalize_complex_dep(pool, req, &dq, CPLXDEPS_EXPAND);
 502   if (i == 0 || i == 1)
 503     {
 504       queue_free(&dq);
 505       return;
 506     }
 507   for (i = 0; i < dq.count; i++)
 508     {
 509       blk = i;
 510       for (; (p = dq.elements[i]) != 0; i++)
 511         {
 512           if (p < 0)
 513             {
 514               if (!MAPTST(installedm, -p))
 515                 break;
 516             }
 517           else if (p == ip)
 518             break;
 519         }
 520       if (!p)
 521         {
 522           for (i = blk; (p = dq.elements[i]) != 0; i++)
 523             {
 524               if (p < 0)
 525                 continue;
 526               if (MAPTST(im, p))
 527                 continue;
 528               if (!MAPTST(installedm, p))
 529                 continue;
 530               if (p == ip || MAPTST(userinstalled, p - pool->installed->start))
 531                 continue;
 532 #ifdef CLEANDEPSDEBUG
 533               printf("%s requires/recommends %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
 534 #endif
 535               MAPSET(im, p);
 536               queue_push(iq, p);
 537             }
 538         }
 539       while (dq.elements[i])
 540         i++;
 541     }
 542   queue_free(&dq);
 543 }
 544
 545 #endif
 546
 547 static inline int
 548 queue_contains(Queue *q, Id id)
 549 {
 550   int i;
 551   for (i = 0; i < q->count; i++)
 552     if (q->elements[i] == id)
 553       return 1;
 554   return 0;
 555 }
 556
 557 static void
 558 find_update_seeds(Solver *solv, Queue *updatepkgs_filtered, Map *userinstalled)
 559 {
 560   Pool *pool = solv->pool;
 561   Repo *installed = solv->installed;
 562   Queue *cleandeps_updatepkgs = solv->cleandeps_updatepkgs;
 563   int i, j;
 564   Id p;
 565
 566   queue_prealloc(updatepkgs_filtered, cleandeps_updatepkgs->count);
 567   for (i = 0; i < cleandeps_updatepkgs->count; i++)
 568     {
 569       p = cleandeps_updatepkgs->elements[i];
 570       if (pool->solvables[p].repo == installed)
 571         {
 572 #ifdef ENABLE_LINKED_PKGS
 573           const char *name = pool_id2str(pool, pool->solvables[p].name);
 574           if (strncmp(name, "pattern:", 8) == 0 || strncmp(name, "application:", 12) == 0)
 575             continue;
 576 #endif
 577           queue_push(updatepkgs_filtered, p);
 578         }
 579     }
 580 #ifdef CLEANDEPSDEBUG
 581   printf("SEEDS IN (%d)\n", updatepkgs_filtered->count);
 582   for (i = 0; i < updatepkgs_filtered->count; i++)
 583     printf("  - %s\n", pool_solvid2str(pool, updatepkgs_filtered->elements[i]));
 584 #endif
 585   filter_unneeded(solv, updatepkgs_filtered, 0, 1);
 586 #ifdef CLEANDEPSDEBUG
 587   printf("SEEDS OUT (%d)\n", updatepkgs_filtered->count);
 588   for (i = 0; i < updatepkgs_filtered->count; i++)
 589     printf("  - %s\n", pool_solvid2str(pool, updatepkgs_filtered->elements[i]));
 590 #endif
 591   /* make sure userinstalled packages are in the seeds */
 592   for (i = j = 0; i < updatepkgs_filtered->count; i++)
 593     {
 594       p = updatepkgs_filtered->elements[i];
 595       if (!MAPTST(userinstalled, p - installed->start))
 596         updatepkgs_filtered->elements[j++] = p;
 597     }
 598   queue_truncate(updatepkgs_filtered, j);
 599   for (i = 0; i < cleandeps_updatepkgs->count; i++)
 600     {
 601       p = cleandeps_updatepkgs->elements[i];
 602       if (pool->solvables[p].repo == installed)
 603         {
 604 #ifdef ENABLE_LINKED_PKGS
 605           const char *name = pool_id2str(pool, pool->solvables[p].name);
 606           if (strncmp(name, "pattern:", 8) == 0 || strncmp(name, "application:", 12) == 0)
 607             {
 608               queue_push(updatepkgs_filtered, p);
 609               continue;
 610             }
 611 #endif
 612           if (MAPTST(userinstalled, p - installed->start))
 613             queue_push(updatepkgs_filtered, p);
 614         }
 615     }
 616 #ifdef CLEANDEPSDEBUG
 617   printf("SEEDS FINAL\n");
 618   for (i = 0; i < updatepkgs_filtered->count; i++)
 619     printf("  - %s\n", pool_solvid2str(pool, updatepkgs_filtered->elements[i]));
 620 #endif
 621 }
 622
 623 /*
 624  * Find all installed packages that are no longer
 625  * needed regarding the current solver job.
 626  *
 627  * The algorithm is:
 628  * - remove pass: remove all packages that could have
 629  *   been dragged in by the obsoleted packages.
 630  *   i.e. if package A is obsolete and contains "Requires: B",
 631  *   also remove B, as installing A will have pulled in B.
 632  *   after this pass, we have a set of still installed packages
 633  *   with broken dependencies.
 634  * - add back pass:
 635  *   now add back all packages that the still installed packages
 636  *   require.
 637  *
 638  * The cleandeps packages are the packages removed in the first
 639  * pass and not added back in the second pass.
 640  *
 641  * If we search for unneeded packages (unneeded is true), we
 642  * simply remove all packages except the userinstalled ones in
 643  * the first pass.
 644  */
 645 void
 646 solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
 647 {
 648   Pool *pool = solv->pool;
 649   Repo *installed = solv->installed;
 650   Queue *job = &solv->job;
 651   Map userinstalled;
 652   Map im;
 653   Map installedm;
 654   Rule *r;
 655   Id rid, how, what, select;
 656   Id p, pp, ip, jp;
 657   Id req, *reqp, sup, *supp;
 658   Solvable *s;
 659   Queue iq, iqcopy, xsuppq;
 660   Queue updatepkgs_filtered;
 661   int i;
 662
 663   map_empty(cleandepsmap);
 664   if (!installed || installed->end == installed->start)
 665     return;
 666   map_init(&userinstalled, installed->end - installed->start);
 667   map_init(&im, pool->nsolvables);
 668   map_init(&installedm, pool->nsolvables);
 669   queue_init(&iq);
 670   queue_init(&xsuppq);
 671
 672   for (i = 0; i < job->count; i += 2)
 673     {
 674       how = job->elements[i];
 675       if ((how & SOLVER_JOBMASK) == SOLVER_USERINSTALLED)
 676         {
 677           what = job->elements[i + 1];
 678           select = how & SOLVER_SELECTMASK;
 679           if (select == SOLVER_SOLVABLE_ALL || (select == SOLVER_SOLVABLE_REPO && what == installed->repoid))
 680             {
 681               FOR_REPO_SOLVABLES(installed, p, s)
 682                 MAPSET(&userinstalled, p - installed->start);
 683             }
 684           FOR_JOB_SELECT(p, pp, select, what)
 685             if (pool->solvables[p].repo == installed)
 686               MAPSET(&userinstalled, p - installed->start);
 687         }
 688       if ((how & (SOLVER_JOBMASK | SOLVER_SELECTMASK)) == (SOLVER_ERASE | SOLVER_SOLVABLE_PROVIDES))
 689         {
 690           what = job->elements[i + 1];
 691           if (ISRELDEP(what))
 692             {
 693               Reldep *rd = GETRELDEP(pool, what);
 694               if (rd->flags != REL_NAMESPACE)
 695                 continue;
 696               if (rd->evr == 0)
 697                 {
 698                   queue_pushunique(&iq, rd->name);
 699                   continue;
 700                 }
 701               FOR_PROVIDES(p, pp, what)
 702                 if (p)
 703                   break;
 704               if (p)
 705                 continue;
 706               queue_pushunique(&iq, what);
 707             }
 708         }
 709     }
 710
 711   /* have special namespace cleandeps erases */
 712   if (iq.count)
 713     {
 714       for (ip = installed->start; ip < installed->end; ip++)
 715         {
 716           s = pool->solvables + ip;
 717           if (s->repo != installed)
 718             continue;
 719           if (!s->supplements)
 720             continue;
 721           supp = s->repo->idarraydata + s->supplements;
 722           while ((sup = *supp++) != 0)
 723             if (ISRELDEP(sup) && check_xsupp(solv, &iq, sup) && !check_xsupp(solv, 0, sup))
 724               {
 725 #ifdef CLEANDEPSDEBUG
 726                 printf("xsupp %s from %s\n", pool_dep2str(pool, sup), pool_solvid2str(pool, ip));
 727 #endif
 728                 queue_pushunique(&xsuppq, sup);
 729               }
 730         }
 731       queue_empty(&iq);
 732     }
 733
 734   /* also add visible patterns to userinstalled for openSUSE */
 735   if (1)
 736     {
 737       Dataiterator di;
 738       dataiterator_init(&di, pool, 0, 0, SOLVABLE_ISVISIBLE, 0, 0);
 739       while (dataiterator_step(&di))
 740         {
 741           Id *dp;
 742           if (di.solvid <= 0)
 743             continue;
 744           s = pool->solvables + di.solvid;
 745           if (!s->repo || !s->requires)
 746             continue;
 747           if (s->repo != installed && !pool_installable(pool, s))
 748             continue;
 749           if (strncmp(pool_id2str(pool, s->name), "pattern:", 8) != 0)
 750             continue;
 751           for (dp = s->repo->idarraydata + s->requires; *dp; dp++)
 752             FOR_PROVIDES(p, pp, *dp)
 753               if (pool->solvables[p].repo == installed)
 754                 {
 755                   if (strncmp(pool_id2str(pool, pool->solvables[p].name), "pattern", 7) != 0)
 756                     continue;
 757                   MAPSET(&userinstalled, p - installed->start);
 758                 }
 759         }
 760       dataiterator_free(&di);
 761     }
 762   if (1)
 763     {
 764       /* all products and their buddies are userinstalled */
 765       for (p = installed->start; p < installed->end; p++)
 766         {
 767           Solvable *s = pool->solvables + p;
 768           if (s->repo != installed)
 769             continue;
 770           if (!strncmp("product:", pool_id2str(pool, s->name), 8))
 771             {
 772               MAPSET(&userinstalled, p - installed->start);
 773 #ifdef ENABLE_LINKED_PKGS
 774               if (solv->instbuddy && solv->instbuddy[p - installed->start] > 1)
 775                 {
 776                   Id buddy = solv->instbuddy[p - installed->start];
 777                   if (buddy >= installed->start && buddy < installed->end)
 778                     MAPSET(&userinstalled, buddy - installed->start);
 779                 }
 780 #endif
 781             }
 782         }
 783     }
 784
 785   /* add all positive elements (e.g. locks) to "userinstalled" */
 786   for (rid = solv->jobrules; rid < solv->jobrules_end; rid++)
 787     {
 788       r = solv->rules + rid;
 789       if (r->d < 0)
 790         continue;
 791       i = solv->ruletojob.elements[rid - solv->jobrules];
 792       if ((job->elements[i] & SOLVER_CLEANDEPS) == SOLVER_CLEANDEPS)
 793         continue;
 794       FOR_RULELITERALS(p, jp, r)
 795         if (p > 0 && pool->solvables[p].repo == installed)
 796           MAPSET(&userinstalled, p - installed->start);
 797     }
 798
 799   /* add all cleandeps candidates to iq */
 800   for (rid = solv->jobrules; rid < solv->jobrules_end; rid++)
 801     {
 802       r = solv->rules + rid;
 803       if (r->d < 0)                             /* disabled? */
 804         continue;
 805       if (r->d == 0 && r->p < 0 && r->w2 == 0)  /* negative assertion (erase job)? */
 806         {
 807           p = -r->p;
 808           if (pool->solvables[p].repo != installed)
 809             continue;
 810           MAPCLR(&userinstalled, p - installed->start);
 811           if (unneeded)
 812             continue;
 813           i = solv->ruletojob.elements[rid - solv->jobrules];
 814           how = job->elements[i];
 815           if ((how & (SOLVER_JOBMASK|SOLVER_CLEANDEPS)) == (SOLVER_ERASE|SOLVER_CLEANDEPS))
 816             queue_push(&iq, p);
 817         }
 818       else if (r->p > 0)                        /* install job */
 819         {
 820           if (unneeded)
 821             continue;
 822           i = solv->ruletojob.elements[rid - solv->jobrules];
 823           if ((job->elements[i] & SOLVER_CLEANDEPS) == SOLVER_CLEANDEPS)
 824             {
 825               /* check if the literals all obsolete some installed package */
 826               Map om;
 827               int iqstart;
 828
 829               /* just one installed literal */
 830               if (r->d == 0 && r->w2 == 0 && pool->solvables[r->p].repo == installed)
 831                 continue;
 832               /* multiversion is bad */
 833               if (solv->multiversion.size && !solv->keepexplicitobsoletes)
 834                 {
 835                   FOR_RULELITERALS(p, jp, r)
 836                     if (MAPTST(&solv->multiversion, p))
 837                       break;
 838                   if (p)
 839                     continue;   /* found a multiversion package that will not obsolate anything */
 840                 }
 841
 842               om.size = 0;
 843               iqstart = iq.count;
 844               FOR_RULELITERALS(p, jp, r)
 845                 {
 846                   if (p < 0)
 847                     {
 848                       queue_truncate(&iq, iqstart);     /* abort */
 849                       break;
 850                     }
 851                   if (pool->solvables[p].repo == installed)
 852                     {
 853                       if (iq.count == iqstart)
 854                         queue_push(&iq, p);
 855                       else
 856                         {
 857                           for (i = iqstart; i < iq.count; i++)
 858                             if (iq.elements[i] == p)
 859                               break;
 860                           queue_truncate(&iq, iqstart);
 861                           if (i < iq.count)
 862                             queue_push(&iq, p);
 863                         }
 864                     }
 865                   else
 866                     solver_intersect_obsoleted(solv, p, &iq, iqstart, &om);
 867                   if (iq.count == iqstart)
 868                     break;
 869                 }
 870               if (om.size)
 871                 map_free(&om);
 872             }
 873         }
 874     }
 875   queue_init_clone(&iqcopy, &iq);
 876
 877   if (!unneeded)
 878     {
 879       if (solv->cleandeps_updatepkgs)
 880         for (i = 0; i < solv->cleandeps_updatepkgs->count; i++)
 881           queue_push(&iq, solv->cleandeps_updatepkgs->elements[i]);
 882     }
 883
 884   if (unneeded)
 885     queue_empty(&iq);   /* just in case... */
 886
 887   /* clear userinstalled bit for the packages we really want to delete/update */
 888   for (i = 0; i < iq.count; i++)
 889     {
 890       p = iq.elements[i];
 891       if (pool->solvables[p].repo != installed)
 892         continue;
 893       MAPCLR(&userinstalled, p - installed->start);
 894     }
 895
 896   for (p = installed->start; p < installed->end; p++)
 897     {
 898       if (pool->solvables[p].repo != installed)
 899         continue;
 900       MAPSET(&installedm, p);
 901       if (pool->considered && !MAPTST(pool->considered, p))
 902         MAPSET(&userinstalled, p - installed->start);   /* we may not remove those */
 903       if (unneeded && !MAPTST(&userinstalled, p - installed->start))
 904         continue;
 905       MAPSET(&im, p);
 906     }
 907   MAPSET(&installedm, SYSTEMSOLVABLE);
 908   MAPSET(&im, SYSTEMSOLVABLE);
 909
 910   if (!unneeded && solv->cleandeps_updatepkgs)
 911     {
 912       /* find update "seeds" */
 913       queue_init(&updatepkgs_filtered);
 914       find_update_seeds(solv, &updatepkgs_filtered, &userinstalled);
 915     }
 916
 917 #ifdef CLEANDEPSDEBUG
 918   printf("REMOVE PASS\n");
 919 #endif
 920
 921   for (;;)
 922     {
 923       if (!iq.count)
 924         {
 925           if (unneeded)
 926             break;
 927           /* supplements pass */
 928           for (ip = installed->start; ip < installed->end; ip++)
 929             {
 930               if (!MAPTST(&installedm, ip))
 931                 continue;
 932               s = pool->solvables + ip;
 933               if (!s->supplements)
 934                 continue;
 935               if (!MAPTST(&im, ip))
 936                 continue;
 937               if (MAPTST(&userinstalled, ip - installed->start))
 938                 continue;
 939               supp = s->repo->idarraydata + s->supplements;
 940               while ((sup = *supp++) != 0)
 941                 if (solver_dep_possible(solv, sup, &im))
 942                   break;
 943               if (!sup)
 944                 {
 945                   supp = s->repo->idarraydata + s->supplements;
 946                   while ((sup = *supp++) != 0)
 947                     if (solver_dep_possible(solv, sup, &installedm) || (xsuppq.count && queue_contains(&xsuppq, sup)))
 948                       {
 949                         /* no longer supplemented, also erase */
 950                         int iqcount = iq.count;
 951                         /* pin packages, see comment above dep_pkgcheck */
 952                         dep_pkgcheck(solv, sup, &im, &iq);
 953                         for (i = iqcount; i < iq.count; i++)
 954                           {
 955                             Id pqp = iq.elements[i];
 956                             if (pool->solvables[pqp].repo == installed)
 957                               MAPSET(&userinstalled, pqp - installed->start);
 958                           }
 959                         queue_truncate(&iq, iqcount);
 960 #ifdef CLEANDEPSDEBUG
 961                         printf("%s supplemented [%s]\n", pool_solvid2str(pool, ip), pool_dep2str(pool, sup));
 962 #endif
 963                         queue_push(&iq, ip);
 964                       }
 965                 }
 966             }
 967           if (!iq.count)
 968             break;      /* no supplementing package found, we're done */
 969         }
 970       ip = queue_shift(&iq);
 971       s = pool->solvables + ip;
 972       if (!MAPTST(&im, ip))
 973         continue;
 974       if (!MAPTST(&installedm, ip))
 975         continue;
 976       if (s->repo == installed && MAPTST(&userinstalled, ip - installed->start))
 977         continue;
 978       MAPCLR(&im, ip);
 979 #ifdef CLEANDEPSDEBUG
 980       printf("removing %s\n", pool_solvable2str(pool, s));
 981 #endif
 982       if (s->requires)
 983         {
 984           reqp = s->repo->idarraydata + s->requires;
 985           while ((req = *reqp++) != 0)
 986             {
 987               if (req == SOLVABLE_PREREQMARKER)
 988                 continue;
 989 #ifdef ENABLE_COMPLEX_DEPS
 990               if (pool_is_complex_dep(pool, req))
 991                 {
 992                   complex_cleandeps_remove(pool, ip, req, &im, &installedm, &iq);
 993                   continue;
 994                 }
 995 #endif
 996               FOR_PROVIDES(p, pp, req)
 997                 {
 998                   if (p != SYSTEMSOLVABLE && MAPTST(&im, p))
 999                     {
1000 #ifdef CLEANDEPSDEBUG
1001                       printf("%s requires %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
1002 #endif
1003                       queue_push(&iq, p);
1004                     }
1005                 }
1006             }
1007         }
1008       if (s->recommends)
1009         {
1010           reqp = s->repo->idarraydata + s->recommends;
1011           while ((req = *reqp++) != 0)
1012             {
1013 #ifdef ENABLE_COMPLEX_DEPS
1014               if (pool_is_complex_dep(pool, req))
1015                 {
1016                   complex_cleandeps_remove(pool, ip, req, &im, &installedm, &iq);
1017                   continue;
1018                 }
1019 #endif
1020               FOR_PROVIDES(p, pp, req)
1021                 {
1022                   if (p != SYSTEMSOLVABLE && MAPTST(&im, p))
1023                     {
1024 #ifdef CLEANDEPSDEBUG
1025                       printf("%s recommends %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
1026 #endif
1027                       queue_push(&iq, p);
1028                     }
1029                 }
1030             }
1031         }
1032     }
1033
1034   /* turn userinstalled into remove set for pruning */
1035   map_empty(&userinstalled);
1036   for (rid = solv->jobrules; rid < solv->jobrules_end; rid++)
1037     {
1038       r = solv->rules + rid;
1039       if (r->p >= 0 || r->d != 0 || r->w2 != 0)
1040         continue;       /* disabled or not erase */
1041       p = -r->p;
1042       MAPCLR(&im, p);
1043       if (pool->solvables[p].repo == installed)
1044         MAPSET(&userinstalled, p - installed->start);
1045     }
1046   if (!unneeded && solv->cleandeps_updatepkgs)
1047     {
1048       for (i = 0; i < solv->cleandeps_updatepkgs->count; i++)
1049         {
1050           p = solv->cleandeps_updatepkgs->elements[i];
1051           if (pool->solvables[p].repo == installed)
1052             MAPSET(&userinstalled, p - installed->start);
1053         }
1054     }
1055   MAPSET(&im, SYSTEMSOLVABLE);  /* in case we cleared it above */
1056   for (p = installed->start; p < installed->end; p++)
1057     if (MAPTST(&im, p))
1058       queue_push(&iq, p);
1059   for (rid = solv->jobrules; rid < solv->jobrules_end; rid++)
1060     {
1061       r = solv->rules + rid;
1062       if (r->d < 0)
1063         continue;
1064       FOR_RULELITERALS(p, jp, r)
1065         if (p > 0)
1066           queue_push(&iq, p);
1067     }
1068   /* also put directly addressed packages on the install queue
1069    * so we can mark patterns as installed */
1070   for (i = 0; i < job->count; i += 2)
1071     {
1072       how = job->elements[i];
1073       if ((how & SOLVER_JOBMASK) == SOLVER_USERINSTALLED)
1074         {
1075           what = job->elements[i + 1];
1076           select = how & SOLVER_SELECTMASK;
1077           if (select == SOLVER_SOLVABLE && pool->solvables[what].repo != installed)
1078             queue_push(&iq, what);
1079         }
1080     }
1081
1082 #ifdef CLEANDEPSDEBUG
1083   printf("ADDBACK PASS\n");
1084 #endif
1085   for (;;)
1086     {
1087       if (!iq.count)
1088         {
1089           /* supplements pass */
1090           for (ip = installed->start; ip < installed->end; ip++)
1091             {
1092               if (!MAPTST(&installedm, ip))
1093                 continue;
1094               if (MAPTST(&userinstalled, ip - installed->start))
1095                 continue;
1096               s = pool->solvables + ip;
1097               if (!s->supplements)
1098                 continue;
1099               if (MAPTST(&im, ip))
1100                 continue;
1101               supp = s->repo->idarraydata + s->supplements;
1102               while ((sup = *supp++) != 0)
1103                 if (solver_dep_possible(solv, sup, &im))
1104                   break;
1105               if (sup)
1106                 {
1107 #ifdef CLEANDEPSDEBUG
1108                   printf("%s supplemented\n", pool_solvid2str(pool, ip));
1109 #endif
1110                   MAPSET(&im, ip);
1111                   queue_push(&iq, ip);
1112                 }
1113             }
1114           if (!iq.count)
1115             break;
1116         }
1117       ip = queue_shift(&iq);
1118       s = pool->solvables + ip;
1119 #ifdef CLEANDEPSDEBUG
1120       printf("adding back %s\n", pool_solvable2str(pool, s));
1121 #endif
1122       if (s->repo == installed && pool->implicitobsoleteusescolors)
1123         {
1124           unsigned int a, bestscore = 0;
1125           FOR_PROVIDES(p, pp, s->name)
1126             {
1127               Solvable *ps = pool->solvables + p;
1128               if (ps->name != s->name || ps->repo == installed)
1129                 continue;
1130               a = pool_arch2score(pool, ps->arch);
1131               if (a && a != 1 && (!bestscore || a < bestscore))
1132                 bestscore = a;
1133             }
1134           if (bestscore && pool_arch2score(pool, s->arch) != bestscore)
1135             {
1136               FOR_PROVIDES(p, pp, s->name)
1137                 {
1138                   Solvable *ps = pool->solvables + p;
1139                   if (ps->repo == installed && ps->name == s->name && ps->evr == s->evr && ps->arch != s->arch && pool_arch2score(pool, ps->arch) == bestscore)
1140                     if (!MAPTST(&im, p))
1141                       {
1142 #ifdef CLEANDEPSDEBUG
1143                         printf("%s lockstep %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
1144 #endif
1145                         MAPSET(&im, p);
1146                         queue_push(&iq, p);
1147                       }
1148                 }
1149             }
1150         }
1151       if (s->requires)
1152         {
1153           reqp = s->repo->idarraydata + s->requires;
1154           while ((req = *reqp++) != 0)
1155             {
1156 #ifdef ENABLE_COMPLEX_DEPS
1157               if (pool_is_complex_dep(pool, req))
1158                 {
1159                   complex_cleandeps_addback(pool, ip, req, &im, &installedm, &iq, &userinstalled);
1160                   continue;
1161                 }
1162 #endif
1163               FOR_PROVIDES(p, pp, req)
1164                 if (p == ip)
1165                   break;
1166               if (p)
1167                 continue;
1168               FOR_PROVIDES(p, pp, req)
1169                 {
1170                   if (MAPTST(&im, p))
1171                     continue;
1172                   if (MAPTST(&installedm, p))
1173                     {
1174                       if (p == ip)
1175                         continue;
1176                       if (MAPTST(&userinstalled, p - installed->start))
1177                         continue;
1178 #ifdef CLEANDEPSDEBUG
1179                       printf("%s requires %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
1180 #endif
1181                       MAPSET(&im, p);
1182                       queue_push(&iq, p);
1183                     }
1184                 }
1185             }
1186         }
1187       if (s->recommends)
1188         {
1189           reqp = s->repo->idarraydata + s->recommends;
1190           while ((req = *reqp++) != 0)
1191             {
1192 #ifdef ENABLE_COMPLEX_DEPS
1193               if (pool_is_complex_dep(pool, req))
1194                 {
1195                   complex_cleandeps_addback(pool, ip, req, &im, &installedm, &iq, &userinstalled);
1196                   continue;
1197                 }
1198 #endif
1199               FOR_PROVIDES(p, pp, req)
1200                 if (p == ip)
1201                   break;
1202               if (p)
1203                 continue;
1204               FOR_PROVIDES(p, pp, req)
1205                 {
1206                   if (MAPTST(&im, p))
1207                     continue;
1208                   if (MAPTST(&installedm, p))
1209                     {
1210                       if (p == ip)
1211                         continue;
1212                       if (MAPTST(&userinstalled, p - installed->start))
1213                         continue;
1214 #ifdef CLEANDEPSDEBUG
1215                       printf("%s recommends %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
1216 #endif
1217                       MAPSET(&im, p);
1218                       queue_push(&iq, p);
1219                     }
1220                 }
1221             }
1222         }
1223     }
1224
1225   queue_free(&iq);
1226   /* make sure the updatepkgs and mistakes are not in the cleandeps map */
1227   if (!unneeded && solv->cleandeps_updatepkgs)
1228     {
1229       for (i = 0; i < updatepkgs_filtered.count; i++)
1230         MAPSET(&im, updatepkgs_filtered.elements[i]);
1231       queue_free(&updatepkgs_filtered);
1232     }
1233   if (solv->cleandeps_mistakes)
1234     for (i = 0; i < solv->cleandeps_mistakes->count; i++)
1235       MAPSET(&im, solv->cleandeps_mistakes->elements[i]);
1236   /* also remove original iq packages */
1237   for (i = 0; i < iqcopy.count; i++)
1238     MAPSET(&im, iqcopy.elements[i]);
1239   queue_free(&iqcopy);
1240   for (p = installed->start; p < installed->end; p++)
1241     {
1242       if (pool->solvables[p].repo != installed)
1243         continue;
1244       if (pool->considered && !MAPTST(pool->considered, p))
1245           continue;
1246       if (!MAPTST(&im, p))
1247         MAPSET(cleandepsmap, p - installed->start);
1248     }
1249   map_free(&im);
1250   map_free(&installedm);
1251   map_free(&userinstalled);
1252   queue_free(&xsuppq);
1253 #ifdef CLEANDEPSDEBUG
1254   printf("=== final cleandeps map:\n");
1255   for (p = installed->start; p < installed->end; p++)
1256     if (MAPTST(cleandepsmap, p - installed->start))
1257       printf("  - %s\n", pool_solvid2str(pool, p));
1258 #endif
1259 }
1260
1261 void
1262 solver_get_unneeded(Solver *solv, Queue *unneededq, int filtered)
1263 {
1264   Repo *installed = solv->installed;
1265   int i;
1266   Map cleandepsmap;
1267
1268   queue_empty(unneededq);
1269   if (!installed || installed->end == installed->start)
1270     return;
1271
1272   map_init(&cleandepsmap, installed->end - installed->start);
1273   solver_createcleandepsmap(solv, &cleandepsmap, 1);
1274   for (i = installed->start; i < installed->end; i++)
1275     if (MAPTST(&cleandepsmap, i - installed->start))
1276       queue_push(unneededq, i);
1277
1278   if (filtered)
1279     filter_unneeded(solv, unneededq, &cleandepsmap, 0);
1280   map_free(&cleandepsmap);
1281 }
1282
1283 static void
1284 add_cleandeps_mistake(Solver *solv, Id p)
1285 {
1286  if (!solv->cleandeps_mistakes)
1287     {
1288       solv->cleandeps_mistakes = solv_calloc(1, sizeof(Queue));
1289       queue_init(solv->cleandeps_mistakes);
1290     }
1291   queue_push(solv->cleandeps_mistakes, p);
1292   MAPCLR(&solv->cleandepsmap, p - solv->installed->start);
1293   solver_reenablepolicyrules_cleandeps(solv, p);
1294 }
1295
1296 static inline int
1297 cleandeps_rule_is_true(Solver *solv, Rule *r)
1298 {
1299   Pool *pool = solv->pool;
1300   Id p, pp;
1301   FOR_RULELITERALS(p, pp, r)
1302     if (p > 0 && solv->decisionmap[p] > 0)
1303       return 1;
1304   return 0;
1305 }
1306
1307 int
1308 solver_check_cleandeps_mistakes(Solver *solv)
1309 {
1310   Pool *pool = solv->pool;
1311   Repo *installed = solv->installed;
1312   Rule *fr;
1313   int i, j, nj;
1314   int mademistake = 0;
1315
1316   if (!solv->cleandepsmap.size || !installed)
1317     return 0;
1318   /* check for mistakes */
1319   policy_update_recommendsmap(solv);
1320   for (i = installed->start; i < installed->end; i++)
1321     {
1322       if (pool->solvables[i].repo != installed)
1323         continue;
1324       if (solv->decisionmap[i] > 0)
1325         {
1326           Id req, *reqp;
1327           Solvable *s = pool->solvables + i;
1328           /* kept package, check requires. we need to do this for things like requires(pre) */
1329           reqp = s->repo->idarraydata + s->requires;
1330           while ((req = *reqp++) != 0)
1331             {
1332               Id p2, pp2;
1333               FOR_PROVIDES(p2, pp2, req)
1334                 {
1335                   if (pool->solvables[p2].repo != installed)
1336                     continue;
1337                   if (p2 == i || solv->decisionmap[p2] > 0)
1338                     continue;
1339                   if (!MAPTST(&solv->cleandepsmap, p2 - installed->start))
1340                     continue;
1341                   POOL_DEBUG(SOLV_DEBUG_SOLVER, "cleandeps requires mistake: %s %s %s\n", pool_solvid2str(pool, i), pool_dep2str(pool, req), pool_solvid2str(pool, p2));
1342                   add_cleandeps_mistake(solv, p2);
1343                   mademistake = 1;
1344                 }
1345             }
1346         }
1347       if (!MAPTST(&solv->cleandepsmap, i - installed->start))
1348         continue;
1349       /* a mistake is when the featurerule is true but the updaterule is false */
1350       fr = solv->rules + solv->featurerules + (i - installed->start);
1351       if (!fr->p)
1352         fr = solv->rules + solv->updaterules + (i - installed->start);
1353       if (!fr->p)
1354         continue;
1355       if (!cleandeps_rule_is_true(solv, fr))
1356         {
1357           /* feature rule is not true, thus we cleandeps erased the package */
1358           /* check if the package is recommended/supplemented. if yes, we made a mistake. */
1359           if (!MAPTST(&solv->recommendsmap, i) && !solver_is_supplementing(solv, pool->solvables + i))
1360             continue;   /* feature rule is not true */
1361           POOL_DEBUG(SOLV_DEBUG_SOLVER, "cleandeps recommends mistake: ");
1362           solver_printruleclass(solv, SOLV_DEBUG_SOLVER, fr);
1363         }
1364       else
1365         {
1366           Rule *r = solv->rules + solv->updaterules + (i - installed->start);
1367           if (!r->p || r == fr || cleandeps_rule_is_true(solv, r))
1368             {
1369               /* update rule is true, check best rules */
1370               if (!solv->bestrules_info)
1371                 continue;
1372               nj = solv->bestrules_end - solv->bestrules;
1373               for (j = solv->bestrules_up - solv->bestrules; j < nj; j++)
1374                 if (solv->bestrules_info[j] == i)
1375                   {
1376                     r = solv->rules + solv->bestrules + j;
1377                     if (!cleandeps_rule_is_true(solv, r))
1378                       break;
1379                   }
1380               if (j == nj)
1381                 continue;
1382             }
1383           POOL_DEBUG(SOLV_DEBUG_SOLVER, "cleandeps mistake: ");
1384           solver_printruleclass(solv, SOLV_DEBUG_SOLVER, r);
1385           POOL_DEBUG(SOLV_DEBUG_SOLVER, "feature rule: ");
1386           solver_printruleclass(solv, SOLV_DEBUG_SOLVER, fr);
1387         }
1388       add_cleandeps_mistake(solv, i);
1389       mademistake = 1;
1390     }
1391   return mademistake;
1392 }