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

diff --git a/src/rules.c b/src/rules.c
index c5b6917..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 */
@@ -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,15 +1183,108 @@ 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 select, how, what, p, pi, pp, pip, 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);
@@ -1173,104 +1296,46 @@ solver_createdupmaps(Solver *solv)
       switch (how & SOLVER_JOBMASK)
 	{
 	case SOLVER_DISTUPGRADE:
-	  if (select != SOLVER_SOLVABLE_REPO)
+	  if (select == SOLVER_SOLVABLE_REPO)
+	    {
+	      Repo *repo;
+	      if (what <= 0 || what > pool->nrepos)
+		break;
+	      repo = pool_id2repo(pool, what);
+	      if (!repo)
+		break;
+	      if (repo != installed && !(how & SOLVER_TARGETED) && solv->noautotarget)
+		break;
+	      targeted = repo != installed || (how & SOLVER_TARGETED) != 0;
+	      FOR_REPO_SOLVABLES(repo, p, s)
+		{
+		  if (repo != installed && !pool_installable(pool, s))
+		    continue;
+		  solver_addtodupmaps(solv, p, how, targeted);
+		}
+	    }
+	  else
 	    {
-	      int haveinstalled;
-	      p = 0;
-	      if (solv->installed)
+	      targeted = how & SOLVER_TARGETED ? 1 : 0;
+	      if (installed && !targeted && !solv->noautotarget)
 		{
 		  FOR_JOB_SELECT(p, pp, select, what)
-		    if (pool->solvables[p].repo == solv->installed)
+		    if (pool->solvables[p].repo == installed)
 		      break;
+		  targeted = p == 0;
 		}
-	      haveinstalled = 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 (haveinstalled && s->repo != solv->installed)
+		  if (s->repo != installed && !targeted)
 		    continue;
-		  if (s->repo != solv->installed && !pool_installable(pool, s))
-		    continue;
-		  MAPSET(&solv->dupinvolvedmap, p);
-		  if (!haveinstalled)
-		    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 (haveinstalled && ps->repo != solv->installed)
-		        MAPSET(&solv->dupmap, pi);
-		    }
-		  if (haveinstalled)
-		    {
-		      if (solv->obsoletes && solv->obsoletes[p - solv->installed->start])
-			{
-			  Id *opp;
-			  for (opp = solv->obsoletes_data + solv->obsoletes[p - solv->installed->start]; (pi = *opp++) != 0;)
-			    {
-			      ps = pool->solvables + pi;
-			      if (ps->repo == solv->installed)
-				continue;
-			      MAPSET(&solv->dupinvolvedmap, pi);
-			      MAPSET(&solv->dupmap, pi);
-			    }
-			}
-		    }
-		  else if (s->obsoletes)
-		    {
-		      /* XXX: 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);
-			    }
-			}
-		    }
-		}
-	      break;
-	    }
-	  if (what <= 0 || what > pool->nrepos)
-	    break;
-	  repo = pool_id2repo(pool, what);
-	  FOR_REPO_SOLVABLES(repo, p, s)
-	    {
-	      if (repo != solv->installed && !pool_installable(pool, s))
-		continue;
-	      MAPSET(&solv->dupmap, p);
-	      FOR_PROVIDES(pi, pip, s->name)
-		{
-		  ps = pool->solvables + pi;
-		  if (ps->name != s->name)
+		  if (s->repo != installed && !pool_installable(pool, s))
 		    continue;
-		  MAPSET(&solv->dupinvolvedmap, pi);
-		}
-	      if (s->obsoletes)
-		{
-		  /* XXX: 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);
-			}
-		    }
+		  solver_addtodupmaps(solv, p, how, targeted);
 		}
 	    }
 	  break;
@@ -1334,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))
@@ -2067,10 +2134,14 @@ solver_ruleinfo(Solver *solv, Id rid, Id *fromp, Id *top, Id *depp)
 	*depp = solv->job.elements[jidx + 1];
       if ((r->d == 0 || r->d == -1) && r->w2 == 0 && r->p == -SYSTEMSOLVABLE)
 	{
-	  if ((solv->job.elements[jidx] & SOLVER_SELECTMASK) == SOLVER_SOLVABLE_NAME)
+	  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_SELECTMASK) == SOLVER_SOLVABLE_PROVIDES)
+	  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;
     }
@@ -2102,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;
@@ -2130,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)
@@ -2141,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);
@@ -2185,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)
@@ -2207,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;
@@ -2324,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;
@@ -2348,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;
@@ -2375,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
 
 /*
@@ -2420,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.
@@ -2453,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);
@@ -2466,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)
     {
@@ -2481,6 +2793,50 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
 	    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 */
@@ -2494,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;
@@ -2551,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)
@@ -2566,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;
@@ -2623,6 +2979,7 @@ solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
 	    }
 	}
     }
+  queue_init_clone(&iqcopy, &iq);
 
   if (!unneeded)
     {
@@ -2652,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");
@@ -2664,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;
@@ -2683,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;
@@ -2697,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;
@@ -2736,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));
@@ -2761,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));
@@ -2785,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);
@@ -2857,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))
 		    {
@@ -2879,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))
 		    {
@@ -2898,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)
@@ -2914,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
 }