X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Frules.c;h=729268d7c5fb0e0f1919acb3791933bb8a49941c;hb=1e554802e7188a10cc9040d5067d7ebf6b3fe0f3;hp=335b01ef3d7f0a98be4f3469ff12f2df9d0a17db;hpb=baca23f183939f0d0b68b60179878b14ce89af47;p=platform%2Fupstream%2Flibsolv.git

diff --git a/src/rules.c b/src/rules.c
index 335b01e..729268d 100644
--- a/src/rules.c
+++ b/src/rules.c
@@ -35,8 +35,8 @@ static void solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unnee
 /*-------------------------------------------------------------------
  * Check if dependency is possible
  * 
- * mirrors solver_dep_fulfilled but uses map m instead of the decisionmap
- * used in solver_addrpmrulesforweak and solver_createcleandepsmap
+ * mirrors solver_dep_fulfilled but uses map m instead of the decisionmap.
+ * used in solver_addrpmrulesforweak and solver_createcleandepsmap.
  */
 
 static inline int
@@ -122,7 +122,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);
 }
@@ -507,13 +507,15 @@ solver_addrpmrulesforsolvable(Solver *solv, Solvable *s, Map *m)
 	  dontfix = 1;			/* dont care about broken rpm deps */
         }
 
-      if (!dontfix
-	  && s->arch != ARCH_SRC
-	  && s->arch != ARCH_NOSRC
-	  && !pool_installable(pool, s))
+      if (!dontfix)
 	{
-	  POOL_DEBUG(SOLV_DEBUG_RULE_CREATION, "package %s [%d] is not installable\n", pool_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_solvable2str(pool, s), (Id)(s - pool->solvables));
+	      addrpmrule(solv, -n, 0, SOLVER_RULE_RPM_NOT_INSTALLABLE, 0);
+	    }
 	}
 
       /* yet another SUSE hack, sigh */
@@ -665,7 +667,7 @@ solver_addrpmrulesforsolvable(Solver *solv, Solvable *s, Map *m)
 	{
 	  int noobs = solv->noobsoletes.size && MAPTST(&solv->noobsoletes, n);
 	  int isinstalled = (installed && s->repo == installed);
-	  if (s->obsoletes && !noobs)
+	  if (s->obsoletes && (!noobs || solv->keepexplicitobsoletes))
 	    {
 	      obsp = s->repo->idarraydata + s->obsoletes;
 	      /* foreach obsoletes */
@@ -773,8 +775,10 @@ solver_addrpmrulesforweak(Solver *solv, Map *m)
 	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)
@@ -958,6 +962,13 @@ solver_addupdaterule(Solver *solv, Solvable *s, int allow_all)
 	    }
 	  qs.count = j;
 	}
+      else if (p != -SYSTEMSOLVABLE)
+	{
+	  /* could fallthrough, but then we would do pool_queuetowhatprovides twice */
+	  queue_free(&qs);
+	  solver_addrule(solv, p, d);	/* allow update of s */
+	  return;
+	}
     }
   if (qs.count && p == -SYSTEMSOLVABLE)
     p = queue_shift(&qs);
@@ -978,6 +989,14 @@ 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_pkg)
+    {
+      int i, ni;
+      ni = solv->bestrules_end - solv->bestrules;
+      for (i = 0; i < ni; i++)
+	if (solv->bestrules_pkg[i] == p)
+	  solver_disablerule(solv, solv->rules + solv->bestrules + i);
+    }
 }
 
 static inline void 
@@ -990,26 +1009,37 @@ reenableupdaterule(Solver *solv, Id p)
   r = solv->rules + solv->updaterules + (p - solv->installed->start);
   if (r->p)
     {    
-      if (r->d >= 0)
-	return;
-      solver_enablerule(solv, r);
-      IF_POOLDEBUG (SOLV_DEBUG_SOLUTIONS)
+      if (r->d < 0)
 	{
-	  POOL_DEBUG(SOLV_DEBUG_SOLUTIONS, "@@@ re-enabling ");
-	  solver_printruleclass(solv, SOLV_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 (SOLV_DEBUG_SOLUTIONS)
+      r = solv->rules + solv->featurerules + (p - solv->installed->start);
+      if (r->p && r->d < 0)
 	{
-	  POOL_DEBUG(SOLV_DEBUG_SOLUTIONS, "@@@ re-enabling ");
-	  solver_printruleclass(solv, SOLV_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_pkg)
+    {
+      int i, ni;
+      ni = solv->bestrules_end - solv->bestrules;
+      for (i = 0; i < ni; i++)
+	if (solv->bestrules_pkg[i] == p)
+	  solver_enablerule(solv, solv->rules + solv->bestrules + i);
+    }
 }
 
 
@@ -1153,56 +1183,159 @@ reenableinfarchrule(Solver *solv, Id name)
  ***
  ***/
 
+static inline void 
+add_cleandeps_package(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 inline void
+solver_addtodupmaps(Solver *solv, Id p, Id how, int targeted)
+{
+  Pool *pool = solv->pool;
+  Solvable *ps, *s = pool->solvables + p;
+  Repo *installed = solv->installed;
+  Id pi, pip, obs, *obsp;
+
+  MAPSET(&solv->dupinvolvedmap, p);
+  if (targeted)
+    MAPSET(&solv->dupmap, p);
+  FOR_PROVIDES(pi, pip, s->name)
+    {
+      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])
+	{
+	  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)
+	{
+	  if (!solv->bestupdatemap.size)
+	    map_grow(&solv->bestupdatemap, installed->end - installed->start);
+	  MAPSET(&solv->bestupdatemap, pi - installed->start);
+	}
+      if (ps->repo == installed && (how & SOLVER_CLEANDEPS) != 0)
+	add_cleandeps_package(solv, pi);
+      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)
+	    {
+	      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])
+		{
+		  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)
+		{
+		  if (!solv->bestupdatemap.size)
+		    map_grow(&solv->bestupdatemap, installed->end - installed->start);
+		  MAPSET(&solv->bestupdatemap, pi - installed->start);
+		}
+	      if (ps->repo == installed && (how & SOLVER_CLEANDEPS) != 0)
+		add_cleandeps_package(solv, pi);
+	    }
+	}
+    }
+}
+
 void
 solver_createdupmaps(Solver *solv)
 {
   Queue *job = &solv->job;
   Pool *pool = solv->pool;
-  Repo *repo;
-  Id how, what, p, pi, pp, obs, *obsp;
-  Solvable *s, *ps;
-  int i;
+  Repo *installed = solv->installed;
+  Id select, how, what, p, pp;
+  Solvable *s;
+  int i, targeted;
 
   map_init(&solv->dupmap, pool->nsolvables);
   map_init(&solv->dupinvolvedmap, pool->nsolvables);
   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 ((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)
+	  if (select == SOLVER_SOLVABLE_REPO)
 	    {
-	      MAPSET(&solv->dupmap, p);
-	      FOR_PROVIDES(pi, pp, s->name)
+	      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)
 		{
-		  ps = pool->solvables + pi;
-		  if (ps->name != s->name)
+		  if (repo != installed && !pool_installable(pool, s))
 		    continue;
-		  MAPSET(&solv->dupinvolvedmap, pi);
+		  solver_addtodupmaps(solv, p, how, targeted);
 		}
-	      if (s->obsoletes)
+	    }
+	  else
+	    {
+	      targeted = how & SOLVER_TARGETED ? 1 : 0;
+	      if (installed && !targeted && !solv->noautotarget)
 		{
-		  /* 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);
-			}
-		    }
+		  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;
@@ -1266,6 +1399,8 @@ solver_addduprules(Solver *solv, Map *addedmap)
 		    }
 		  if (!ip)
 		    solver_addrule(solv, -p, 0);	/* no match, sorry */
+		  else
+		    MAPSET(&solv->dupmap, p);		/* for best rules processing */
 		}
 	    }
 	  else if (!MAPTST(&solv->dupmap, p))
@@ -1325,7 +1460,8 @@ reenableduprule(Solver *solv, Id name)
 
 /* 
  * add all installed packages that package p obsoletes to Queue q.
- * Package p is not installed and not in oobs map.
+ * Package p is not installed. Also, we know that if
+ * solv->keepexplicitobsoletes is not set, p is not in the noobs map.
  * Entries may get added multiple times.
  */
 static void
@@ -1338,18 +1474,20 @@ add_obsoletes(Solver *solv, Id p, Queue *q)
   Id obs, *obsp;
   Id lastp2 = 0;
 
-  /* we already know: p is not installed, p is not noobs */
-  FOR_PROVIDES(p2, pp2, s->name)
+  if (!solv->keepexplicitobsoletes || !(solv->noobsoletes.size && MAPTST(&solv->noobsoletes, p)))
     {
-      Solvable *ps = pool->solvables + p2;
-      if (ps->repo != installed)
-	continue;
-      if (!pool->implicitobsoleteusesprovides && ps->name != s->name)
-	continue;
-      if (pool->obsoleteusescolors && !pool_colormatch(pool, s, ps)) 
-	continue;
-      queue_push(q, p2);
-      lastp2 = p2;
+      FOR_PROVIDES(p2, pp2, s->name)
+	{
+	  Solvable *ps = pool->solvables + p2;
+	  if (ps->repo != installed)
+	    continue;
+	  if (!pool->implicitobsoleteusesprovides && ps->name != s->name)
+	    continue;
+	  if (pool->obsoleteusescolors && !pool_colormatch(pool, s, ps)) 
+	    continue;
+	  queue_push(q, p2);
+	  lastp2 = p2;
+	}
     }
   if (!s->obsoletes)
     return;
@@ -1453,22 +1591,25 @@ jobtodisablelist(Solver *solv, Id how, Id what, Queue *q)
       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_SETARCH | SOLVER_SETVENDOR | SOLVER_SETREPO | SOLVER_SETEVR;
+	    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 !defined(DEBIAN_SEMANTICS)
-		  const char *evr = pool_id2str(pool, rd->evr);
-		  if (strchr(evr, '-'))
-		    set |= SOLVER_SETEVR;
+		  if (pool->disttype != DISTTYPE_DEB)
+		    {
+		      const char *evr = pool_id2str(pool, rd->evr);
+		      if (strchr(evr, '-'))
+			set |= SOLVER_SETEVR;
+		      else
+			set |= SOLVER_SETEV;
+		    }
 		  else
-		    set |= SOLVER_SETEV;
-#else
-		  set |= SOLVER_SETEVR;
-#endif
+		    set |= SOLVER_SETEVR;
 		}
 	      if (rd->flags <= 7 && ISRELDEP(rd->name))
 		rd = GETRELDEP(pool, rd->name);
@@ -1487,6 +1628,8 @@ jobtodisablelist(Solver *solv, Id how, Id what, Queue *q)
 	  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;
@@ -1530,7 +1673,7 @@ jobtodisablelist(Solver *solv, Id how, Id what, Queue *q)
 	{
 	  if (pool->solvables[p].repo == installed)
 	    j = p;
-	  else if (solv->noobsoletes.size && MAPTST(&solv->noobsoletes, p))
+	  else if (solv->noobsoletes.size && MAPTST(&solv->noobsoletes, p) && !solv->keepexplicitobsoletes)
 	    return;
 	  i++;
 	}
@@ -1580,6 +1723,8 @@ jobtodisablelist(Solver *solv, Id how, Id what, Queue *q)
 	      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)
@@ -1608,6 +1753,9 @@ jobtodisablelist(Solver *solv, Id how, Id what, Queue *q)
     case SOLVER_ERASE:
       if (!installed)
 	break;
+      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);
@@ -1984,8 +2132,17 @@ 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)
+	{
+	  if ((solv->job.elements[jidx] & (SOLVER_JOBMASK|SOLVER_SELECTMASK)) == (SOLVER_INSTALL|SOLVER_SOLVABLE_NAME))
+	    return SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP;
+	  if ((solv->job.elements[jidx] & (SOLVER_JOBMASK|SOLVER_SELECTMASK)) == (SOLVER_INSTALL|SOLVER_SOLVABLE_PROVIDES))
+	    return SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP;
+	  if ((solv->job.elements[jidx] & (SOLVER_JOBMASK|SOLVER_SELECTMASK)) == (SOLVER_ERASE|SOLVER_SOLVABLE_NAME))
+	    return SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM;
+	  if ((solv->job.elements[jidx] & (SOLVER_JOBMASK|SOLVER_SELECTMASK)) == (SOLVER_ERASE|SOLVER_SOLVABLE_PROVIDES))
+	    return SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM;
+	}
       return SOLVER_RULE_JOB;
     }
   if (rid >= solv->updaterules && rid < solv->updaterules_end)
@@ -2016,6 +2173,10 @@ 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)
+    {
+      return SOLVER_RULE_BEST;
+    }
   if (rid >= solv->choicerules && rid < solv->choicerules_end)
     {
       return SOLVER_RULE_CHOICE;
@@ -2044,6 +2205,8 @@ solver_ruleclass(Solver *solv, Id rid)
     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->choicerules && rid < solv->choicerules_end)
     return SOLVER_RULE_CHOICE;
   if (rid >= solv->learntrules)
@@ -2055,7 +2218,7 @@ void
 solver_ruleliterals(Solver *solv, Id rid, Queue *q)
 {
   Pool *pool = solv->pool;
-  Id p, *pp;
+  Id p, pp;
   Rule *r;
 
   queue_empty(q);
@@ -2099,9 +2262,11 @@ solver_addchoicerules(Solver *solv)
   Rule *r;
   Queue q, qi;
   int i, j, rid, havechoice;
-  Id p, d, *pp;
+  Id p, d, pp;
   Id p2, pp2;
   Solvable *s, *s2;
+  Id lastaddedp, lastaddedd;
+  int lastaddedcnt;
 
   solv->choicerules = solv->nrules;
   if (!pool->installed)
@@ -2121,6 +2286,9 @@ solver_addchoicerules(Solver *solv)
   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->rpmrules_end ; rid++)
     {
       r = solv->rules + rid;
@@ -2238,7 +2406,22 @@ solver_addchoicerules(Solver *solv)
 #endif
 	  continue;
 	}
+
+      /* 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;
+
+      lastaddedp = r->p;
+      lastaddedd = d;
+      lastaddedcnt = q.count;
+
       solver_addrule(solv, r->p, d);
       queue_push(&solv->weakruleq, solv->nrules - 1);
       solv->choicerules_ref[solv->nrules - 1 - solv->choicerules] = rid;
@@ -2262,7 +2445,7 @@ solver_addchoicerules(Solver *solv)
 void
 solver_disablechoicerules(Solver *solv, Rule *r)
 {
-  Id rid, p, *pp;
+  Id rid, p, pp;
   Pool *pool = solv->pool;
   Map m;
   Rule *or;
@@ -2289,6 +2472,167 @@ solver_disablechoicerules(Solver *solv, Rule *r)
     }
 }
 
+static void
+prune_to_update_targets(Solver *solv, Id *cp, Queue *q)
+{
+  int i, j;
+  Id p, *cp2; 
+  for (i = j = 0; i < q->count; i++)
+    {  
+      p = q->elements[i];
+      for (cp2 = cp; *cp2; cp2++)
+        if (*cp2 == p)
+          {
+            q->elements[j++] = p;
+            break;
+          }
+    }
+  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++)
+    {
+      Id p = q->elements[i];
+      if (MAPTST(&solv->dupmap, p))
+	q->elements[j++] = p;
+    }
+  queue_truncate(q, j);
+}
+
+void
+solver_addbestrules(Solver *solv, int havebestinstalljobs)
+{
+  Pool *pool = solv->pool;
+  Id p;
+  Solvable *s;
+  Repo *installed = solv->installed;
+  Queue q, q2;
+  Rule *r;
+  Queue r2pkg;
+  int i, oldcnt;
+
+  solv->bestrules = solv->nrules;
+  if (!installed)
+    {
+      solv->bestrules_end = solv->nrules;
+      return;
+    }
+  queue_init(&q);
+  queue_init(&q2);
+  queue_init(&r2pkg);
+
+  if (havebestinstalljobs)
+    {
+      for (i = 0; i < solv->job.count; i += 2)
+	{
+	  if ((solv->job.elements[i] & (SOLVER_JOBMASK | SOLVER_FORCEBEST)) == (SOLVER_INSTALL | SOLVER_FORCEBEST))
+	    {
+	      int j;
+	      Id p2, pp2;
+	      for (j = 0; j < solv->ruletojob.count; j++)
+		if (solv->ruletojob.elements[j] == i)
+		  break;
+	      if (j == solv->ruletojob.count)
+		continue;
+	      r = solv->rules + solv->jobrules + j;
+	      queue_empty(&q);
+	      FOR_RULELITERALS(p2, pp2, r)
+		if (p2 > 0)
+		  queue_push(&q, p2);
+	      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 */
+	      p2 = queue_shift(&q);
+	      solver_addrule(solv, p2, q.count ? pool_queuetowhatprovides(pool, &q) : 0);
+	      queue_push(&r2pkg, -(solv->jobrules + j));
+	    }
+	}
+    }
+
+  if (solv->bestupdatemap_all || solv->bestupdatemap.size)
+    {
+      FOR_REPO_SOLVABLES(installed, p, s)
+	{
+	  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
+	    {
+	      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->multiversionupdaters && (d = solv->multiversionupdaters[p - installed->start]) != 0 && r == solv->rules + solv->updaterules + (p - installed->start))
+	    {
+	      /* need to check multiversionupdaters */
+	      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 (solv->update_targets && solv->update_targets->elements[p - installed->start])
+	    prune_to_update_targets(solv, solv->update_targets->elements + solv->update_targets->elements[p - 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);
+	  if (!q.count)
+	    continue;	/* orphaned */
+	  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);
+		  if (solv->update_targets && solv->update_targets->elements[p - installed->start])
+		    prune_to_update_targets(solv, solv->update_targets->elements + solv->update_targets->elements[p - installed->start], &q2);
+		  if (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p))
+		    prune_to_dup_packages(solv, p, &q);
+		  policy_filter_unwanted(solv, &q2, POLICY_MODE_RECOMMEND);
+		  for (j = 0; j < q2.count; j++)
+		    queue_pushunique(&q, q2.elements[j]);
+		}
+	    }
+	  p2 = queue_shift(&q);
+	  solver_addrule(solv, p2, q.count ? pool_queuetowhatprovides(pool, &q) : 0);
+	  queue_push(&r2pkg, p);
+	}
+    }
+  if (r2pkg.count)
+    {
+      solv->bestrules_pkg = solv_calloc(r2pkg.count, sizeof(Id));
+      memcpy(solv->bestrules_pkg, r2pkg.elements, r2pkg.count * sizeof(Id));
+    }
+  solv->bestrules_end = solv->nrules;
+  queue_free(&q);
+  queue_free(&q2);
+  queue_free(&r2pkg);
+}
+
 #undef CLEANDEPSDEBUG
 
 /*
@@ -2334,6 +2678,59 @@ dep_pkgcheck(Solver *solv, Id dep, Map *m, Queue *q)
       queue_push(q, p);
 }
 
+static int
+check_xsupp(Solver *solv, Queue *depq, Id dep)
+{
+  Pool *pool = solv->pool;
+  Id p, pp;
+
+  if (ISRELDEP(dep))
+    {
+      Reldep *rd = GETRELDEP(pool, dep);
+      if (rd->flags >= 8)
+	{
+	  if (rd->flags == REL_AND)
+	    {
+	      if (!check_xsupp(solv, depq, rd->name))
+		return 0;
+	      return check_xsupp(solv, depq, rd->evr);
+	    }
+	  if (rd->flags == REL_OR)
+	    {
+	      if (check_xsupp(solv, depq, rd->name))
+		return 1;
+	      return check_xsupp(solv, depq, rd->evr);
+	    }
+	  if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_SPLITPROVIDES)
+	    return solver_splitprovides(solv, rd->evr);
+	  if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_INSTALLED)
+	    return solver_dep_installed(solv, rd->evr);
+	}
+      if (depq && rd->flags == REL_NAMESPACE)
+	{
+	  int i;
+	  for (i = 0; i < depq->count; i++)
+	    if (depq->elements[i] == dep || depq->elements[i] == rd->name)
+	     return 1;
+	}
+    }
+  FOR_PROVIDES(p, pp, dep)
+    if (p == SYSTEMSOLVABLE || pool->solvables[p].repo == solv->installed)
+      return 1;
+  return 0;
+}
+
+static inline int
+queue_contains(Queue *q, Id id)
+{
+  int i;
+  for (i = 0; i < q->count; i++)
+    if (q->elements[i] == id)
+      return 1;
+  return 0;
+}
+
+
 /*
  * Find all installed packages that are no longer
  * needed regarding the current solver job.
@@ -2367,10 +2764,10 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
   Map installedm;
   Rule *r;
   Id rid, how, what, select;
-  Id p, pp, ip, *jp;
+  Id p, pp, ip, jp;
   Id req, *reqp, sup, *supp;
   Solvable *s;
-  Queue iq;
+  Queue iq, iqcopy, xsuppq;
   int i;
 
   map_empty(cleandepsmap);
@@ -2380,6 +2777,7 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
   map_init(&im, pool->nsolvables);
   map_init(&installedm, pool->nsolvables);
   queue_init(&iq);
+  queue_init(&xsuppq);
 
   for (i = 0; i < job->count; i += 2)
     {
@@ -2388,10 +2786,57 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
 	{
 	  what = job->elements[i + 1];
 	  select = how & SOLVER_SELECTMASK;
+	  if (select == SOLVER_SOLVABLE_ALL || (select == SOLVER_SOLVABLE_REPO && what == installed->repoid))
+	    FOR_REPO_SOLVABLES(installed, p, s)
+	      MAPSET(&userinstalled, p - installed->start);
 	  FOR_JOB_SELECT(p, pp, select, what)
 	    if (pool->solvables[p].repo == installed)
 	      MAPSET(&userinstalled, p - installed->start);
 	}
+      if ((how & (SOLVER_JOBMASK | SOLVER_SELECTMASK)) == (SOLVER_ERASE | SOLVER_SOLVABLE_PROVIDES))
+	{
+	  what = job->elements[i + 1];
+	  if (ISRELDEP(what))
+	    {
+	      Reldep *rd = GETRELDEP(pool, what);
+	      if (rd->flags != REL_NAMESPACE)
+		continue;
+	      if (rd->evr == 0)
+		{
+		  queue_pushunique(&iq, rd->name);
+		  continue;
+		}
+	      FOR_PROVIDES(p, pp, what)
+		if (p)
+		  break;
+	      if (p)
+		continue;
+	      queue_pushunique(&iq, what);
+	    }
+	}
+    }
+
+  /* have special namespace cleandeps erases */
+  if (iq.count)
+    {
+      for (ip = solv->installed->start; ip < solv->installed->end; ip++)
+	{
+	  s = pool->solvables + ip;
+	  if (s->repo != installed)
+	    continue;
+	  if (!s->supplements)
+	    continue;
+	  supp = s->repo->idarraydata + s->supplements;
+	  while ((sup = *supp++) != 0)
+	    if (check_xsupp(solv, &iq, sup) && !check_xsupp(solv, 0, sup))
+	      {
+#ifdef CLEANDEPSDEBUG
+		printf("xsupp %s from %s\n", pool_dep2str(pool, sup), pool_solvid2str(pool, ip));
+#endif
+	        queue_pushunique(&xsuppq, sup);
+	      }
+	}
+      queue_empty(&iq);
     }
 
   /* also add visible patterns to userinstalled for openSUSE */
@@ -2405,9 +2850,9 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
 	  if (di.solvid <= 0)
 	    continue;
 	  s = pool->solvables + di.solvid;
-	  if (!s->requires)
+	  if (!s->repo || !s->requires)
 	    continue;
-	  if (!pool_installable(pool, s))
+	  if (s->repo != installed && !pool_installable(pool, s))
 	    continue;
 	  if (strncmp(pool_id2str(pool, s->name), "pattern:", 8) != 0)
 	    continue;
@@ -2419,7 +2864,7 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
 		  if (strncmp(pool_id2str(pool, pool->solvables[p].name), "pattern", 7) != 0)
 		    continue;
 		  MAPSET(&userinstalled, p - installed->start);
-	    }
+		}
 	}
       dataiterator_free(&di);
     }
@@ -2438,7 +2883,7 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
 		{
 		  Id buddy = pool->nscallback(pool, pool->nscallbackdata, NAMESPACE_PRODUCTBUDDY, p);
 		  if (buddy >= installed->start && buddy < installed->end && pool->solvables[buddy].repo == installed)
-		    MAPSET(&userinstalled, buddy);
+		    MAPSET(&userinstalled, buddy - installed->start);
 		}
 	    }
 	}
@@ -2462,9 +2907,9 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
   for (rid = solv->jobrules; rid < solv->jobrules_end; rid++)
     {
       r = solv->rules + rid;
-      if (r->d < 0)
+      if (r->d < 0)				/* disabled? */
 	continue;
-      if (r->d == 0 && r->p < 0 && r->w2 == 0)
+      if (r->d == 0 && r->p < 0 && r->w2 == 0)	/* negative assertion (erase job)? */
 	{
 	  p = -r->p;
 	  if (pool->solvables[p].repo != installed)
@@ -2477,7 +2922,7 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
 	  if ((how & (SOLVER_JOBMASK|SOLVER_CLEANDEPS)) == (SOLVER_ERASE|SOLVER_CLEANDEPS))
 	    queue_push(&iq, p);
 	}
-      else if (r->p > 0)
+      else if (r->p > 0)			/* install job */
 	{
 	  if (unneeded)
 	    continue;
@@ -2492,7 +2937,7 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
 	      if (r->d == 0 && r->w2 == 0 && pool->solvables[r->p].repo == installed)
 		continue;
 	      /* noobs is bad */
-	      if (solv->noobsoletes.size)
+	      if (solv->noobsoletes.size && !solv->keepexplicitobsoletes)
 		{
 		  FOR_RULELITERALS(p, jp, r)
 		    if (MAPTST(&solv->noobsoletes, p))
@@ -2534,6 +2979,7 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
 	    }
 	}
     }
+  queue_init_clone(&iqcopy, &iq);
 
   if (!unneeded)
     {
@@ -2545,6 +2991,15 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
   if (unneeded)
     queue_empty(&iq);	/* just in case... */
 
+  /* clear userinstalled bit for the packages we really want to delete/update */
+  for (i = 0; i < iq.count; i++)
+    {
+      p = iq.elements[i];
+      if (pool->solvables[p].repo != installed)
+	continue;
+      MAPCLR(&userinstalled, p - installed->start);
+    }
+
   for (p = installed->start; p < installed->end; p++)
     {
       if (pool->solvables[p].repo != installed)
@@ -2554,6 +3009,8 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
 	continue;
       MAPSET(&im, p);
     }
+  MAPSET(&installedm, SYSTEMSOLVABLE);
+  MAPSET(&im, SYSTEMSOLVABLE);
 
 #ifdef CLEANDEPSDEBUG
   printf("REMOVE PASS\n");
@@ -2566,7 +3023,7 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
 	  if (unneeded)
 	    break;
 	  /* supplements pass */
-	  for (ip = solv->installed->start; ip < solv->installed->end; ip++)
+	  for (ip = installed->start; ip < installed->end; ip++)
 	    {
 	      if (!MAPTST(&installedm, ip))
 		continue;
@@ -2575,6 +3032,8 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
 		continue;
 	      if (!MAPTST(&im, ip))
 		continue;
+	      if (MAPTST(&userinstalled, ip - installed->start))
+		continue;
 	      supp = s->repo->idarraydata + s->supplements;
 	      while ((sup = *supp++) != 0)
 		if (dep_possible(solv, sup, &im))
@@ -2583,7 +3042,7 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
 		{
 		  supp = s->repo->idarraydata + s->supplements;
 		  while ((sup = *supp++) != 0)
-		    if (dep_possible(solv, sup, &installedm))
+		    if (dep_possible(solv, sup, &installedm) || (xsuppq.count && queue_contains(&xsuppq, sup)))
 		      {
 		        /* no longer supplemented, also erase */
 			int iqcount = iq.count;
@@ -2597,14 +3056,14 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
 			  }
 			queue_truncate(&iq, iqcount);
 #ifdef CLEANDEPSDEBUG
-		        printf("%s supplemented\n", pool_solvid2str(pool, ip));
+		        printf("%s supplemented [%s]\n", pool_solvid2str(pool, ip), pool_dep2str(pool, sup));
 #endif
 		        queue_push(&iq, ip);
 		      }
 		}
 	    }
 	  if (!iq.count)
-	    break;
+	    break;	/* no supplementing package found, we're done */
 	}
       ip = queue_shift(&iq);
       s = pool->solvables + ip;
@@ -2636,7 +3095,7 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
 #endif
 	      FOR_PROVIDES(p, pp, req)
 		{
-		  if (MAPTST(&im, p))
+		  if (p != SYSTEMSOLVABLE && MAPTST(&im, p))
 		    {
 #ifdef CLEANDEPSDEBUG
 		      printf("%s requires %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
@@ -2661,7 +3120,7 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
 #endif
 	      FOR_PROVIDES(p, pp, req)
 		{
-		  if (MAPTST(&im, p))
+		  if (p != SYSTEMSOLVABLE && MAPTST(&im, p))
 		    {
 #ifdef CLEANDEPSDEBUG
 		      printf("%s recommends %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
@@ -2685,6 +3144,7 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
       if (pool->solvables[p].repo == installed)
         MAPSET(&userinstalled, p - installed->start);
     }
+  MAPSET(&im, SYSTEMSOLVABLE);	/* in case we cleared it above */
   for (p = installed->start; p < installed->end; p++)
     if (MAPTST(&im, p))
       queue_push(&iq, p);
@@ -2757,6 +3217,11 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
 	  while ((req = *reqp++) != 0)
 	    {
 	      FOR_PROVIDES(p, pp, req)
+		if (MAPTST(&im, p))
+		  break;
+	      if (p)
+		continue;
+	      FOR_PROVIDES(p, pp, req)
 		{
 		  if (!MAPTST(&im, p) && MAPTST(&installedm, p))
 		    {
@@ -2779,6 +3244,11 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
 	  while ((req = *reqp++) != 0)
 	    {
 	      FOR_PROVIDES(p, pp, req)
+		if (MAPTST(&im, p))
+		  break;
+	      if (p)
+		continue;
+	      FOR_PROVIDES(p, pp, req)
 		{
 		  if (!MAPTST(&im, p) && MAPTST(&installedm, p))
 		    {
@@ -2798,12 +3268,17 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
     }
     
   queue_free(&iq);
+  /* make sure the updatepkgs and mistakes are not in the cleandeps map */
   if (solv->cleandeps_updatepkgs)
     for (i = 0; i < solv->cleandeps_updatepkgs->count; i++)
       MAPSET(&im, solv->cleandeps_updatepkgs->elements[i]);
   if (solv->cleandeps_mistakes)
     for (i = 0; i < solv->cleandeps_mistakes->count; i++)
       MAPSET(&im, solv->cleandeps_mistakes->elements[i]);
+  /* also remove original iq packages */
+  for (i = 0; i < iqcopy.count; i++)
+    MAPSET(&im, iqcopy.elements[i]);
+  queue_free(&iqcopy);
   for (p = installed->start; p < installed->end; p++)
     {
       if (pool->solvables[p].repo != installed)
@@ -2814,6 +3289,13 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
   map_free(&im);
   map_free(&installedm);
   map_free(&userinstalled);
+  queue_free(&xsuppq);
+#ifdef CLEANDEPSDEBUG
+  printf("=== final cleandeps map:\n");
+  for (p = installed->start; p < installed->end; p++)
+    if (MAPTST(cleandepsmap, p - installed->start))
+      printf("  - %s\n", pool_solvid2str(pool, p));
+#endif
 }
 
 
@@ -2831,39 +3313,35 @@ trj_visit(struct trj_data *trj, Id node)
 {
   Id *low = trj->low;
   Queue *edges = trj->edges;
-  Id myidx, stackstart;
+  Id nnode, myidx, stackstart;
   int i;
 
   low[node] = myidx = trj->idx++;
   low[(stackstart = trj->nstack++)] = node;
-  if (edges->elements[node])
+  for (i = edges->elements[node]; (nnode = edges->elements[i]) != 0; i++)
     {
-      Id nnode;
-      for (i = edges->elements[node]; (nnode = edges->elements[i]) != 0; i++)
+      Id l = low[nnode];
+      if (!l)
 	{
-	  Id l = low[nnode];
-	  if (!l)
+	  if (!edges->elements[edges->elements[nnode]])
 	    {
-	      if (!edges->elements[nnode])
-		{
-		  trj->idx++;
-		  low[nnode] = -1;
-		  continue;
-		}
-	      trj_visit(trj, nnode);
-	      l = low[nnode];
-	    }
-	  if (l < 0)
-	    continue;
-	  if (l < trj->firstidx)
-	    {
-	      int k;
-	      for (k = l; low[low[k]] == l; k++)
-	        low[low[k]] = -1;
+	      trj->idx++;
+	      low[nnode] = -1;
+	      continue;
 	    }
-	  else if (l < low[node])
-	    low[node] = l;
+	  trj_visit(trj, nnode);
+	  l = low[nnode];
+	}
+      if (l < 0)
+	continue;
+      if (l < trj->firstidx)
+	{
+	  int k;
+	  for (k = l; low[low[k]] == l; k++)
+	    low[low[k]] = -1;
 	}
+      else if (l < low[node])
+	low[node] = l;
     }
   if (low[node] == myidx)
     {
@@ -2875,155 +3353,6 @@ trj_visit(struct trj_data *trj, Id node)
     }
 }
 
-/*
- * low will contain the result of the SCC search.
- * it must be of at least size 2 * (count + 1) and
- * must be zero initialized.
- * The layout is:
- *    0  low low ... low stack stack ...stack 0
- *            count              count
- */
-static inline void
-trj_run(Id *low, int count, Queue *edges)
-{
-  struct trj_data trj;
-  int i;
-
-  trj.edges = edges;
-  trj.low = low;
-  trj.idx = count + 1;	/* stack starts here */
-  for (i = 1; i <= count; i++)
-    {
-      if (low[i])
-	continue;
-      if (edges->elements[i])
-	{
-	  trj.firstidx = trj.nstack = trj.idx;
-	  trj_visit(&trj, i);
-	}
-      else
-	{
-	  Id myidx = trj.idx++;
-	  low[i] = myidx;
-	  low[myidx] = i;
-	}
-    }
-}
-
-/*
- * Go through the solvables in the nodes queue and create edges for
- * all requires/recommends/supplements between the nodes.
- * The edges are stored in the edges queue, we add 1 to the node
- * index so that nodes in the edges queue are != 0 and we can
- * terminate the edge list with 0.
- * Thus for node element 5, the edges are stored starting at
- * edges->elements[6] and are 0-terminated.
- */
-static void
-unneeded_create_edges(Solver *solv, Queue *nodes, Queue *edges, Map *installedm, Map *checkm, int norequires)
-{
-  Pool *pool = solv->pool;
-  Repo *installed = solv->installed;
-  int count = nodes->count;
-  int i, j;
-
-  queue_empty(edges);
-
-  /* leave first element zero to make things easier */
-  /* also add trailing zero */
-  queue_insertn(edges, 0, count + 1 + 1);
-
-  /* first requires and recommends */
-  for (i = 0; i < count; i++)
-    {
-      Solvable *s = pool->solvables + nodes->elements[i];
-      int pass;
-
-      edges->elements[i + 1] = edges->count;
-      for (pass = norequires ? 1 : 0; pass < 2; pass++)
-	{
-	  unsigned int off = pass == 0 ? s->requires : s->recommends;
-	  Id p, pp, *dp;
-	  if (!off)
-	    continue;
-	  for (dp = s->repo->idarraydata + off; *dp; dp++)
-	    FOR_PROVIDES(p, pp, *dp)
-	      {
-		Solvable *sp = pool->solvables + p;
-		if (s == sp || sp->repo != installed || !MAPTST(checkm, p - installed->start))
-		  continue;
-		for (j = 0; j < count; j++)
-		  if (p == nodes->elements[j])
-		    break;
-		if (j < count && edges->elements[edges->count - 1] != j + 1)
-		  queue_push(edges, j + 1);
-	      }
-	}
-      queue_push(edges, 0);
-    }
-
-#if 0
-  printf("requires + recommends\n");
-  for (i = 0; i < count; i++)
-    {
-      int j;
-      printf("  %s:\n", pool_solvid2str(pool, nodes->elements[i]));
-      for (j = edges->elements[i + 1]; edges->elements[j]; j++)
-	printf("    - %s\n", pool_solvid2str(pool, nodes->elements[edges->elements[j] - 1]));
-    }
-#endif
-
-  /* then add supplements */
-  for (i = 0; i < count; i++)
-    {
-      Solvable *s = pool->solvables + nodes->elements[i];
-      if (s->supplements)
-	{
-	  Id *dp;
-	  int k;
-	  for (dp = s->repo->idarraydata + s->supplements; *dp; dp++)
-	    if (dep_possible(solv, *dp, installedm))
-	      {
-		Queue iq;
-		Id iqbuf[16];
-		queue_init_buffer(&iq, iqbuf, sizeof(iqbuf)/sizeof(*iqbuf));
-		dep_pkgcheck(solv, *dp, 0, &iq);
-		for (k = 0; k < iq.count; k++)
-		  {
-		    Id p = iq.elements[k];
-		    Solvable *sp = pool->solvables + p;
-		    if (p == nodes->elements[i] || sp->repo != installed || !MAPTST(checkm, p - installed->start))
-		      continue;
-		    for (j = 0; j < count; j++)
-		      if (p == nodes->elements[j])
-			break;
-		    /* now add edge from j + 1 to i + 1 */
-		    queue_insert(edges, edges->elements[j + 1], i + 1);
-		    /* addapt following edge pointers */
-		    for (k = j + 2; k < count + 2; k++)
-		      edges->elements[k]++;
-		  }
-		queue_free(&iq);
-	      }
-	}
-    }
-#if 0
-  /* print result */
-  printf("+ supplements\n");
-  for (i = 0; i < count; i++)
-    {
-      int j;
-      printf("  %s:\n", pool_solvid2str(pool, nodes->elements[i]));
-      for (j = edges->elements[i + 1]; edges->elements[j]; j++)
-	printf("    - %s\n", pool_solvid2str(pool, nodes->elements[edges->elements[j] - 1]));
-    }
-#endif
-
-  /* make nodes with no edges have 0 in the edge pointer */
-  for (i = 0; i < count; i++)
-    if (!edges->elements[edges->elements[i + 1]])
-      edges->elements[i + 1] = 0;
-}
 
 void
 solver_get_unneeded(Solver *solv, Queue *unneededq, int filtered)
@@ -3045,72 +3374,180 @@ solver_get_unneeded(Solver *solv, Queue *unneededq, int filtered)
   if (filtered && unneededq->count > 1)
     {
       Pool *pool = solv->pool;
-      Queue edges, sccnodes, sccedges;
+      Queue edges;
+      Id *nrequires;
       Map installedm;
-      int j, count = unneededq->count;
+      int j, pass, count = unneededq->count;
       Id *low;
 
-      queue_init(&edges);
-      queue_init(&sccnodes);
-      queue_init(&sccedges);
       map_init(&installedm, pool->nsolvables);
       for (i = installed->start; i < installed->end; i++)
 	if (pool->solvables[i].repo == installed)
 	  MAPSET(&installedm, i);
 
-      unneeded_create_edges(solv, unneededq, &edges, &installedm, &cleandepsmap, 0);
+      nrequires = solv_calloc(count, sizeof(Id));
+      queue_init(&edges);
+      queue_prealloc(&edges, count * 4 + 10);	/* pre-size */
 
-      /* now run SCC algo */
-      /* count + 1: one extra element in front as our nodes start with 1,
-       * 1 extra trailing zero for the stack */
-      low = solv_calloc(count + 1, 2 * sizeof(Id));
-      trj_run(low, count, &edges);
+      /*
+       * Go through the solvables in the nodes queue and create edges for
+       * all requires/recommends/supplements between the nodes.
+       * The edges are stored in the edges queue, we add 1 to the node
+       * index so that nodes in the edges queue are != 0 and we can
+       * terminate the edge list with 0.
+       * Thus for node element 5, the edges are stored starting at
+       * edges.elements[6] and are 0-terminated.
+       */
+      /* leave first element zero to make things easier */
+      /* also add trailing zero */
+      queue_insertn(&edges, 0, 1 + count + 1);
 
-      /* go through every found SCC */
+      /* first requires and recommends */
       for (i = 0; i < count; i++)
 	{
-	  Id l = low[i + 1];
-	  if (l <= 0)
-	    continue;
-	  /* collect scc members */
-	  queue_empty(&sccnodes);
-	  for (j = l; low[low[j]] == l; j++)
+	  Solvable *s = pool->solvables + unneededq->elements[i];
+	  edges.elements[i + 1] = edges.count;
+	  for (pass = 0; pass < 2; pass++)
 	    {
-	      queue_push(&sccnodes, unneededq->elements[low[j] - 1]);
-	      low[low[j]] = -1;
+	      int num = 0;
+	      unsigned int off = pass == 0 ? s->requires : s->recommends;
+	      Id p, pp, *dp;
+	      if (off)
+		for (dp = s->repo->idarraydata + off; *dp; dp++)
+		  FOR_PROVIDES(p, pp, *dp)
+		    {
+		      Solvable *sp = pool->solvables + p;
+		      if (s == sp || sp->repo != installed || !MAPTST(&cleandepsmap, p - installed->start))
+			continue;
+		      for (j = 0; j < count; j++)
+			if (p == unneededq->elements[j])
+			  break;
+		      if (j == count)
+			continue;
+		      if (num && edges.elements[edges.count - 1] == j + 1)
+			continue;
+		      queue_push(&edges, j + 1);
+		      num++;
+		    }
+		if (pass == 0)
+		  nrequires[i] = num;
 	    }
-	  /* If we have more then one element do sub-scc filtering.
-	   * with the requires ignored. The idea is that the filtered
-	   * packages were dragged in via recommends/supplements and
-	   * require the main package. */
-	  if (sccnodes.count > 1)
+	  queue_push(&edges, 0);
+	}
+#if 0
+      printf("requires + recommends\n");
+      for (i = 0; i < count; i++)
+	{
+	  int j;
+	  printf("  %s (%d requires):\n", pool_solvid2str(pool, unneededq->elements[i]), nrequires[i]);
+	  for (j = edges.elements[i + 1]; edges.elements[j]; j++)
+	    printf("    - %s\n", pool_solvid2str(pool, unneededq->elements[edges.elements[j] - 1]));
+	}
+#endif
+
+      /* then add supplements */
+      for (i = 0; i < count; i++)
+	{
+	  Solvable *s = pool->solvables + unneededq->elements[i];
+	  if (s->supplements)
 	    {
-	      Id *scclow;
-	      Id sccbuf[2 * 10];
-
-	      queue_empty(&sccedges);
-	      unneeded_create_edges(solv, &sccnodes, &sccedges, &installedm, &cleandepsmap, 1);
-	      memset(sccbuf, 0, sizeof(sccbuf));
-	      scclow = sccnodes.count + 1 <= 10 ? sccbuf : solv_calloc(sccnodes.count + 1, 2 * sizeof(Id));
-	      trj_run(scclow, sccnodes.count, &sccedges);
-	      for (j = 0; j < sccnodes.count; j++)
-		if (scclow[j + 1] > 0)
-		  MAPCLR(&cleandepsmap, sccnodes.elements[j] - installed->start);
-	      if (scclow != sccbuf)
-	        solv_free(scclow);
+	      Id *dp;
+	      int k;
+	      for (dp = s->repo->idarraydata + s->supplements; *dp; dp++)
+		if (dep_possible(solv, *dp, &installedm))
+		  {
+		    Queue iq;
+		    Id iqbuf[16];
+		    queue_init_buffer(&iq, iqbuf, sizeof(iqbuf)/sizeof(*iqbuf));
+		    dep_pkgcheck(solv, *dp, 0, &iq);
+		    for (k = 0; k < iq.count; k++)
+		      {
+			Id p = iq.elements[k];
+			Solvable *sp = pool->solvables + p;
+			if (p == unneededq->elements[i] || sp->repo != installed || !MAPTST(&cleandepsmap, p - installed->start))
+			  continue;
+			for (j = 0; j < count; j++)
+			  if (p == unneededq->elements[j])
+			    break;
+			/* now add edge from j + 1 to i + 1 */
+			queue_insert(&edges, edges.elements[j + 1] + nrequires[j], i + 1);
+			/* addapt following edge pointers */
+			for (k = j + 2; k < count + 2; k++)
+			  edges.elements[k]++;
+		      }
+		    queue_free(&iq);
+		  }
 	    }
-	  else if (sccnodes.count)
-	    MAPCLR(&cleandepsmap, sccnodes.elements[0] - installed->start);
 	}
+#if 0
+      /* print result */
+      printf("+ supplements\n");
+      for (i = 0; i < count; i++)
+	{
+	  int j;
+	  printf("  %s (%d requires):\n", pool_solvid2str(pool, unneededq->elements[i]), nrequires[i]);
+	  for (j = edges.elements[i + 1]; edges.elements[j]; j++)
+	    printf("    - %s\n", pool_solvid2str(pool, unneededq->elements[edges.elements[j] - 1]));
+    }
+#endif
       map_free(&installedm);
+
+      /* now run SCC algo two times, first with requires+recommends+supplements,
+       * then again without the requires. We run it the second time to get rid
+       * of packages that got dragged in via recommends/supplements */
+      /*
+       * low will contain the result of the SCC search.
+       * it must be of at least size 2 * (count + 1) and
+       * must be zero initialized.
+       * The layout is:
+       *    0  low low ... low stack stack ...stack 0
+       *            count              count
+       */
+      low = solv_calloc(count + 1, 2 * sizeof(Id));
+      for (pass = 0; pass < 2; pass++)
+	{
+	  struct trj_data trj;
+	  if (pass)
+	    {
+	      memset(low, 0, (count + 1) * (2 * sizeof(Id)));
+	      for (i = 0; i < count; i++)
+		{
+	          edges.elements[i + 1] += nrequires[i];
+		  if (!unneededq->elements[i])
+		    low[i + 1] = -1;	/* ignore this node */
+		}
+	    }
+	  trj.edges = &edges;
+	  trj.low = low;
+	  trj.idx = count + 1;	/* stack starts here */
+	  for (i = 1; i <= count; i++)
+	    {
+	      if (low[i])
+		continue;
+	      if (edges.elements[edges.elements[i]])
+		{
+		  trj.firstidx = trj.nstack = trj.idx;
+		  trj_visit(&trj, i);
+		}
+	      else
+		{
+		  Id myidx = trj.idx++;
+		  low[i] = myidx;
+		  low[myidx] = i;
+		}
+	    }
+	  /* prune packages */
+	  for (i = 0; i < count; i++)
+	    if (low[i + 1] <= 0)
+	      unneededq->elements[i] = 0;
+	}
       solv_free(low);
+      solv_free(nrequires);
       queue_free(&edges);
-      queue_free(&sccnodes);
-      queue_free(&sccedges);
 
-      /* finally remove all entries from unneededq that still have the cleandepsmap bit set */
+      /* finally remove all pruned entries from unneededq */
       for (i = j = 0; i < count; i++)
-	if (!MAPTST(&cleandepsmap, unneededq->elements[i] - installed->start))
+	if (unneededq->elements[i])
 	  unneededq->elements[j++] = unneededq->elements[i];
       queue_truncate(unneededq, j);
     }