2 * Copyright (c) 2007, Novell Inc.
4 * This program is licensed under the BSD license, read LICENSE.BSD
5 * for further information
11 * The pool contains information about solvables
12 * stored optimized for memory consumption and fast retrieval.
24 #include "poolid_private.h"
30 #define SOLVABLE_BLOCK 255
33 * list of string constants, so we can do pointer/Id instead of string comparison
34 * index into array matches ID_xxx constants in pool.h
37 static const char *initpool_data[] = {
48 "solvable:recommends",
50 "solvable:supplements",
53 "rpm:dbid", /* direct key into rpmdb */
54 "solvable:prereqmarker",
55 "solvable:filemarker",
56 "namespace:installed",
58 "namespace:splitprovides",
77 pool = (Pool *)sat_calloc(1, sizeof(*pool));
79 stringpool_init (&pool->ss, initpool_data);
81 /* alloc space for ReDep 0 */
82 pool->rels = sat_extend_resize(0, 1, sizeof(Reldep), REL_BLOCK);
84 memset(pool->rels, 0, sizeof(Reldep));
86 /* alloc space for Solvable 0 and system solvable */
87 pool->solvables = sat_extend_resize(0, 2, sizeof(Solvable), SOLVABLE_BLOCK);
89 memset(pool->solvables, 0, 2 * sizeof(Solvable));
90 s = pool->solvables + SYSTEMSOLVABLE;
91 s->name = SYSTEM_SYSTEM;
92 s->arch = ARCH_NOARCH;
95 queue_init(&pool->vendormap);
97 pool->debugmask = SAT_DEBUG_RESULT; /* FIXME */
102 /* free all the resources of our pool */
104 pool_free(Pool *pool)
108 pool_freewhatprovides(pool);
109 pool_freeidhashes(pool);
110 repo_freeallrepos(pool, 1);
111 sat_free(pool->id2arch);
112 sat_free(pool->solvables);
113 sat_free(pool->ss.stringspace);
114 sat_free(pool->ss.strings);
115 sat_free(pool->rels);
116 queue_free(&pool->vendormap);
117 for (i = 0; i < DEP2STRBUF; i++)
118 sat_free(pool->dep2strbuf[i]);
123 pool_add_solvable(Pool *pool)
125 pool->solvables = sat_extend(pool->solvables, pool->nsolvables, 1, sizeof(Solvable), SOLVABLE_BLOCK);
126 memset(pool->solvables + pool->nsolvables, 0, sizeof(Solvable));
127 return pool->nsolvables++;
131 pool_add_solvable_block(Pool *pool, int count)
133 Id nsolvables = pool->nsolvables;
136 pool->solvables = sat_extend(pool->solvables, pool->nsolvables, count, sizeof(Solvable), SOLVABLE_BLOCK);
137 memset(pool->solvables + nsolvables, 0, sizeof(Solvable) * count);
138 pool->nsolvables += count;
143 pool_free_solvable_block(Pool *pool, Id start, int count, int reuseids)
147 if (reuseids && start + count == pool->nsolvables)
149 /* might want to shrink solvable array */
150 pool->nsolvables = start;
153 memset(pool->solvables + start, 0, sizeof(Solvable) * count);
158 solvable2str(Pool *pool, Solvable *s)
160 int l, nn = pool->dep2strn;
161 const char *n, *e, *a;
162 n = id2str(pool, s->name);
163 e = id2str(pool, s->evr);
164 a = id2str(pool, s->arch);
165 l = strlen(n) + strlen(e) + strlen(a) + 3;
166 if (l > pool->dep2strlen[nn])
168 pool->dep2strbuf[nn] = sat_realloc(pool->dep2strbuf[nn], l + 32);
169 pool->dep2strlen[nn] = l + 32;
171 sprintf(pool->dep2strbuf[nn], "%s-%s.%s", n, e, a);
172 pool->dep2strn = (nn + 1) % DEP2STRBUF;
173 return pool->dep2strbuf[nn];
176 static Pool *pool_shrink_whatprovides_sortcmp_data;
179 pool_shrink_whatprovides_sortcmp(const void *ap, const void *bp)
182 Pool *pool = pool_shrink_whatprovides_sortcmp_data;
184 oa = pool->whatprovides[*(Id *)ap];
185 ob = pool->whatprovides[*(Id *)bp];
187 return *(Id *)ap - *(Id *)bp;
192 da = pool->whatprovidesdata + oa;
193 db = pool->whatprovidesdata + ob;
195 if ((r = (*da++ - *db++)) != 0)
199 return *(Id *)ap - *(Id *)bp;
203 * pool_shrink_whatprovides - unify whatprovides data
205 * whatprovides_rel must be empty for this to work!
209 pool_shrink_whatprovides(Pool *pool)
213 Id lastid, *last, *dp, *lp;
217 if (pool->ss.nstrings < 3)
219 sorted = sat_malloc2(pool->ss.nstrings, sizeof(Id));
220 for (id = 0; id < pool->ss.nstrings; id++)
222 pool_shrink_whatprovides_sortcmp_data = pool;
223 qsort(sorted + 1, pool->ss.nstrings - 1, sizeof(Id), pool_shrink_whatprovides_sortcmp);
226 for (i = 1; i < pool->ss.nstrings; i++)
229 o = pool->whatprovides[id];
230 if (o == 0 || o == 1)
232 dp = pool->whatprovidesdata + o;
246 pool->whatprovides[id] = -lastid;
250 last = pool->whatprovidesdata + o;
254 dp = pool->whatprovidesdata + 2;
255 for (id = 1; id < pool->ss.nstrings; id++)
257 o = pool->whatprovides[id];
258 if (o == 0 || o == 1)
265 pool->whatprovides[id] = pool->whatprovides[i];
268 lp = pool->whatprovidesdata + o;
271 pool->whatprovides[id] = dp - pool->whatprovidesdata;
272 while ((*dp++ = *lp++) != 0)
275 o = dp - pool->whatprovidesdata;
276 POOL_DEBUG(SAT_DEBUG_STATS, "shrunk whatprovidesdata from %d to %d\n", pool->whatprovidesdataoff, o);
277 if (pool->whatprovidesdataoff == o)
279 r = pool->whatprovidesdataoff - o;
280 pool->whatprovidesdataoff = o;
281 pool->whatprovidesdata = sat_realloc(pool->whatprovidesdata, (o + pool->whatprovidesdataleft) * sizeof(Id));
282 if (r > pool->whatprovidesdataleft)
283 r = pool->whatprovidesdataleft;
284 memset(pool->whatprovidesdata + o, 0, r * sizeof(Id));
289 * pool_createwhatprovides()
291 * create hashes over pool of solvables to ease provide lookups
295 pool_createwhatprovides(Pool *pool)
297 int i, num, np, extra;
302 Offset *whatprovides;
303 Id *whatprovidesdata, *d;
305 POOL_DEBUG(SAT_DEBUG_STATS, "number of solvables: %d\n", pool->nsolvables);
306 POOL_DEBUG(SAT_DEBUG_STATS, "number of ids: %d + %d\n", pool->ss.nstrings, pool->nrels);
308 pool_freeidhashes(pool); /* XXX: should not be here! */
309 pool_freewhatprovides(pool);
310 num = pool->ss.nstrings;
311 pool->whatprovides = whatprovides = sat_extend_resize(0, num, sizeof(Offset), WHATPROVIDES_BLOCK);
312 memset(whatprovides, 0, num * sizeof(Offset));
313 pool->whatprovides_rel = sat_extend_resize(0, pool->nrels, sizeof(Offset), WHATPROVIDES_BLOCK);
314 memset(pool->whatprovides_rel, 0, pool->nrels * sizeof(Offset));
316 /* count providers for each name */
317 for (i = 1; i < pool->nsolvables; i++)
320 s = pool->solvables + i;
323 if (!pool_installable(pool, s))
325 pp = s->repo->idarraydata + s->provides;
326 while ((id = *pp++) != ID_NULL)
330 Reldep *rd = GETRELDEP(pool, id);
333 whatprovides[id]++; /* inc count of providers */
337 off = 2; /* first entry is undef, second is empty list */
339 np = 0; /* number of names provided */
340 for (i = 0; i < num; i++, idp++)
343 if (!n) /* no providers */
345 *idp = off; /* move from counts to offsets into whatprovidesdata */
346 off += n + 1; /* make space for all providers + terminating ID_NULL */
347 np++; /* inc # of provider 'slots' */
350 POOL_DEBUG(SAT_DEBUG_STATS, "provide ids: %d\n", np);
352 /* reserve some space for relation data */
353 extra = 2 * pool->nrels;
357 POOL_DEBUG(SAT_DEBUG_STATS, "provide space needed: %d + %d\n", off, extra);
359 /* alloc space for all providers + extra */
360 whatprovidesdata = sat_calloc(off + extra, sizeof(Id));
362 /* now fill data for all provides */
363 for (i = 1; i < pool->nsolvables; i++)
366 s = pool->solvables + i;
369 if (!pool_installable(pool, s))
372 /* for all provides of this solvable */
373 pp = s->repo->idarraydata + s->provides;
374 while ((id = *pp++) != 0)
378 Reldep *rd = GETRELDEP(pool, id);
381 d = whatprovidesdata + whatprovides[id]; /* offset into whatprovidesdata */
385 while (*d) /* find free slot */
390 *d = i; /* put solvable Id into data */
393 pool->whatprovidesdata = whatprovidesdata;
394 pool->whatprovidesdataoff = off;
395 pool->whatprovidesdataleft = extra;
396 pool_shrink_whatprovides(pool);
400 * free all of our whatprovides data
401 * be careful, everything internalized with pool_queuetowhatprovides is gone, too
404 pool_freewhatprovides(Pool *pool)
406 pool->whatprovides = sat_free(pool->whatprovides);
407 pool->whatprovides_rel = sat_free(pool->whatprovides_rel);
408 pool->whatprovidesdata = sat_free(pool->whatprovidesdata);
409 pool->whatprovidesdataoff = 0;
410 pool->whatprovidesdataleft = 0;
414 /******************************************************************************/
417 * pool_queuetowhatprovides - add queue contents to whatprovidesdata
419 * on-demand filling of provider information
420 * move queue data into whatprovidesdata
422 * returns: Offset into whatprovides
426 pool_queuetowhatprovides(Pool *pool, Queue *q)
429 int count = q->count;
431 if (count == 0) /* queue empty -> ID_EMPTY */
434 /* extend whatprovidesdata if needed, +1 for ID_NULL-termination */
435 if (pool->whatprovidesdataleft < count + 1)
437 POOL_DEBUG(SAT_DEBUG_STATS, "growing provides hash data...\n");
438 pool->whatprovidesdata = sat_realloc(pool->whatprovidesdata, (pool->whatprovidesdataoff + count + 4096) * sizeof(Id));
439 pool->whatprovidesdataleft = count + 4096;
442 /* copy queue to next free slot */
443 off = pool->whatprovidesdataoff;
444 memcpy(pool->whatprovidesdata + pool->whatprovidesdataoff, q->elements, count * sizeof(Id));
446 /* adapt count and ID_NULL-terminate */
447 pool->whatprovidesdataoff += count;
448 pool->whatprovidesdata[pool->whatprovidesdataoff++] = ID_NULL;
449 pool->whatprovidesdataleft -= count + 1;
455 /*************************************************************************/
460 * add packages fulfilling the relation to whatprovides array
461 * no exact providers, do range match
466 pool_addrelproviders(Pool *pool, Id d)
468 Reldep *rd = GETRELDEP(pool, d);
474 int flags = rd->flags;
476 Id p, *pp, *pp2, *pp3;
479 queue_init_buffer(&plist, buf, sizeof(buf)/sizeof(*buf));
484 pp = pool_whatprovides(pool, name);
485 pp2 = pool_whatprovides(pool, evr);
486 while ((p = *pp++) != 0)
488 for (pp3 = pp2; *pp3;)
491 queue_push(&plist, p);
497 pp = pool_whatprovides(pool, name);
498 while ((p = *pp++) != 0)
499 queue_push(&plist, p);
500 pp = pool_whatprovides(pool, evr);
501 while ((p = *pp++) != 0)
502 queue_pushunique(&plist, p);
505 if (pool->nscallback)
507 p = pool->nscallback(pool, pool->nscallbackdata, name, evr);
511 pool->whatprovides_rel[d] = p;
512 return pool->whatprovidesdata + p;
515 queue_push(&plist, SYSTEMSOLVABLE);
522 /* convert to whatprovides id */
524 POOL_DEBUG(DEBUG_1, "addrelproviders: what provides %s?\n", id2str(pool, name));
526 if (flags && flags < 8)
528 FOR_PROVIDES(p, pp, name)
531 POOL_DEBUG(DEBUG_1, "addrelproviders: checking package %s\n", id2str(pool, pool->p[p].name));
533 /* solvable p provides name in some rels */
534 pidp = pool->solvables[p].repo->idarraydata + pool->solvables[p].provides;
535 while ((pid = *pidp++) != 0)
542 #ifdef DEBIAN_SEMANTICS
543 continue; /* unversioned provides can
544 * never match versioned deps */
546 break; /* yes, provides all versions */
550 continue; /* wrong provides name */
551 prd = GETRELDEP(pool, pid);
552 if (prd->name != name)
553 continue; /* wrong provides name */
554 /* right package, both deps are rels */
558 if (flags == 7 || pflags == 7)
559 break; /* included */
560 if ((pflags & flags & 5) != 0)
561 break; /* same direction, match */
565 if ((pflags & flags & 2) != 0)
566 break; /* both have =, match */
570 int f = flags == 5 ? 5 : flags == 2 ? pflags : (flags ^ 5) & (pflags | 5);
571 if ((f & (1 << (1 + evrcmp(pool, pevr, evr, EVRCMP_MATCH_RELEASE)))) != 0)
576 continue; /* no rel match */
577 queue_push(&plist, p);
579 /* make our system solvable provide all unknown rpmlib() stuff */
580 if (plist.count == 0 && !strncmp(id2str(pool, name), "rpmlib(", 7))
581 queue_push(&plist, SYSTEMSOLVABLE);
583 /* add providers to whatprovides */
585 POOL_DEBUG(DEBUG_1, "addrelproviders: adding %d packages to %d\n", plist.count, d);
587 pool->whatprovides_rel[d] = pool_queuetowhatprovides(pool, &plist);
590 return pool->whatprovidesdata + pool->whatprovides_rel[d];
593 /*************************************************************************/
596 pool_debug(Pool *pool, int type, const char *format, ...)
601 if ((type & (SAT_FATAL|SAT_ERROR)) == 0)
603 if ((pool->debugmask & type) == 0)
606 va_start(args, format);
607 if (!pool->debugcallback)
609 if ((type & (SAT_FATAL|SAT_ERROR)) == 0)
610 vprintf(format, args);
612 vfprintf(stderr, format, args);
615 vsnprintf(buf, sizeof(buf), format, args);
616 pool->debugcallback(pool, pool->debugcallbackdata, type, buf);
620 pool_setdebuglevel(Pool *pool, int level)
622 int mask = SAT_DEBUG_RESULT;
624 mask |= SAT_DEBUG_STATS|SAT_DEBUG_ANALYZE|SAT_DEBUG_UNSOLVABLE;
626 mask |= SAT_DEBUG_JOB|SAT_DEBUG_SOLUTIONS|SAT_DEBUG_POLICY;
628 mask |= SAT_DEBUG_PROPAGATE;
630 mask |= SAT_DEBUG_RULE_CREATION;
632 mask |= SAT_DEBUG_SCHUBI;
633 pool->debugmask = mask;
636 /*************************************************************************/
646 #define SEARCHFILES_BLOCK 127
649 pool_addfileprovides_dep(Pool *pool, Id *ida, struct searchfiles *sf, struct searchfiles *isf)
654 while ((dep = *ida++) != 0)
656 while (ISRELDEP(dep))
659 sid = pool->ss.nstrings + GETRELID(dep);
660 if (MAPTST(&sf->seen, sid))
665 MAPSET(&sf->seen, sid);
666 rd = GETRELDEP(pool, dep);
669 else if (rd->flags == REL_NAMESPACE)
671 if (isf && (rd->name == NAMESPACE_INSTALLED || rd->name == NAMESPACE_SPLITPROVIDES))
675 if (MAPTST(&sf->seen, sid))
680 MAPSET(&sf->seen, sid);
689 pool_addfileprovides_dep(pool, ids, sf, isf);
695 if (MAPTST(&sf->seen, dep))
697 MAPSET(&sf->seen, dep);
698 s = id2str(pool, dep);
701 sf->ids = sat_extend(sf->ids, sf->nfiles, 1, sizeof(const char *), SEARCHFILES_BLOCK);
702 sf->dirs = sat_extend(sf->dirs, sf->nfiles, 1, sizeof(const char *), SEARCHFILES_BLOCK);
703 sf->names = sat_extend(sf->names, sf->nfiles, 1, sizeof(const char *), SEARCHFILES_BLOCK);
704 sf->ids[sf->nfiles] = dep;
705 sr = strrchr(s, '/');
706 sf->names[sf->nfiles] = strdup(sr + 1);
707 sf->dirs[sf->nfiles] = sat_malloc(sr - s + 1);
709 strncpy(sf->dirs[sf->nfiles], s, sr - s);
710 sf->dirs[sf->nfiles][sr - s] = 0;
715 struct addfileprovides_cbdata {
727 addfileprovides_cb(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *value)
729 struct addfileprovides_cbdata *cbd = cbdata;
730 Pool *pool = s->repo->pool;
734 if (data != cbd->olddata)
736 map_free(&cbd->useddirs);
737 map_init(&cbd->useddirs, data->dirpool.ndirs);
738 for (i = 0; i < cbd->nfiles; i++)
740 Id did = repodata_str2dir(data, cbd->dirs[i], 0);
743 MAPSET(&cbd->useddirs, did);
747 if (!MAPTST(&cbd->useddirs, value->id))
749 for (i = 0; i < cbd->nfiles; i++)
751 if (cbd->dids[i] != value->id)
753 if (!strcmp(cbd->names[i], value->str))
756 if (i == cbd->nfiles)
758 s->provides = repo_addid_dep(s->repo, s->provides, cbd->ids[i], SOLVABLE_FILEMARKER);
763 pool_addfileprovides(Pool *pool, Repo *installed)
767 struct searchfiles sf, isf;
768 struct addfileprovides_cbdata cbd;
772 id_filelist = str2id(pool, "filelist", 1);
774 memset(&sf, 0, sizeof(sf));
775 map_init(&sf.seen, pool->ss.nstrings + pool->nrels);
776 memset(&isf, 0, sizeof(isf));
777 map_init(&isf.seen, pool->ss.nstrings + pool->nrels);
779 for (i = 1, s = pool->solvables + i; i < pool->nsolvables; i++, s++)
785 pool_addfileprovides_dep(pool, repo->idarraydata + s->obsoletes, &sf, &isf);
787 pool_addfileprovides_dep(pool, repo->idarraydata + s->conflicts, &sf, &isf);
789 pool_addfileprovides_dep(pool, repo->idarraydata + s->requires, &sf, &isf);
791 pool_addfileprovides_dep(pool, repo->idarraydata + s->recommends, &sf, &isf);
793 pool_addfileprovides_dep(pool, repo->idarraydata + s->suggests, &sf, &isf);
795 pool_addfileprovides_dep(pool, repo->idarraydata + s->supplements, &sf, &isf);
797 pool_addfileprovides_dep(pool, repo->idarraydata + s->enhances, &sf, &isf);
799 pool_addfileprovides_dep(pool, repo->idarraydata + s->freshens, &sf, &isf);
803 POOL_DEBUG(SAT_DEBUG_STATS, "found %d file dependencies\n", sf.nfiles);
804 POOL_DEBUG(SAT_DEBUG_STATS, "found %d installed file dependencies\n", isf.nfiles);
806 map_init(&cbd.useddirs, 1);
810 for (i = 0; i < sf.nfiles; i++)
811 POOL_DEBUG(SAT_DEBUG_STATS, "looking up %s in filelist\n", id2str(pool, sf.ids[i]));
813 cbd.nfiles = sf.nfiles;
816 cbd.names = sf.names;
818 cbd.dids = sat_realloc2(cbd.dids, sf.nfiles, sizeof(Id));
819 pool_search(pool, 0, id_filelist, 0, 0, addfileprovides_cb, &cbd);
821 for (i = 0; i < sf.nfiles; i++)
823 sat_free(sf.dirs[i]);
824 sat_free(sf.names[i]);
829 if (isf.nfiles && installed)
832 for (i = 0; i < isf.nfiles; i++)
833 POOL_DEBUG(SAT_DEBUG_STATS, "looking up %s in installed filelist\n", id2str(pool, isf.ids[i]));
835 cbd.nfiles = isf.nfiles;
838 cbd.names = isf.names;
840 cbd.dids = sat_realloc2(cbd.dids, isf.nfiles, sizeof(Id));
841 repo_search(installed, 0, id_filelist, 0, 0, addfileprovides_cb, &cbd);
843 for (i = 0; i < isf.nfiles; i++)
845 sat_free(isf.dirs[i]);
846 sat_free(isf.names[i]);
851 map_free(&cbd.useddirs);
853 pool_freewhatprovides(pool); /* as we have added provides */
873 struct mountpoint *mps;
879 pool_fill_DU_add_cb(void *data, Solvable *s, Id key, const char *str)
881 struct cbdata *cbdata = data;
882 Id mp, dirnum, kbytes, files;
884 dp = data_read_id(dp, &dirnum);
885 dp = data_read_id(dp, &kbytes);
886 data_read_id(dp, &files);
887 if (dirnum < 0 || dirnum > cbdata->nmap)
889 mp = cbdata->dirmap[dirnum];
892 cbdata->mps[mp].kbytes += kbytes;
893 cbdata->mps[mp].files += files;
899 pool_fill_DU_sub_cb(void *data, Solvable *s, Id key, const char *str)
901 struct cbdata *cbdata = data;
902 Id mp, dirnum, kbytes, files;
904 dp = data_read_id(dp, &dirnum);
905 dp = data_read_id(dp, &kbytes);
906 data_read_id(dp, &files);
907 if (dirnum < 0 || dirnum > cbdata->nmap)
909 mp = cbdata->dirmap[dirnum];
912 cbdata->mps[mp].kbytes -= kbytes;
913 cbdata->mps[mp].files -= files;
919 propagate_mountpoints(struct mptree *mptree, int pos, Id mountpoint)
922 if (mptree[pos].mountpoint == -1)
923 mptree[pos].mountpoint = mountpoint;
925 mountpoint = mptree[pos].mountpoint;
926 for (i = mptree[pos].child; i; i = mptree[i].sibling)
927 propagate_mountpoints(mptree, i, mountpoint);
931 pool_fill_DU(Pool *pool, struct mountpoint *mps, int nmps)
935 struct mptree *mptree;
941 struct cbdata cbdata;
943 memset(&md, 0, sizeof(md));
948 md.callback_data = &cbdata
954 mptree = sat_malloc2(16, sizeof(mptree));
957 mptree[0].sibling = 0;
961 mptree[0].mountpoint = -1;
964 /* create component tree */
965 for (mp = 0; mp < nmps; mp++)
973 if ((p = strchr('/', path)) == 0)
976 compl = strlen(comp);
987 for (i = mptree[pos].child; i; i = mptree[i].sibling)
988 if (mptree[i].compl == compl && !strncmp(mptree[i].comp, comp, compl))
992 /* create new node */
993 if ((nmptree & 15) == 0)
994 mptree = sat_realloc2(mptree, nmptree + 16, sizeof(mptree));
996 mptree[i].sibling = mptree[pos].child;
998 mptree[i].comp = comp;
999 mptree[i].compl = compl;
1000 mptree[i].mountpoint = -1;
1001 mptree[pos].child = i;
1005 mptree[pos].mountpoint = mp;
1007 propagate_mountpoints(mptree, 0, mptree[0].mountpoint);
1011 for_all_repodatas_containing_DU
1013 /* create map from dir to mptree */
1014 dirmap = xcalloc2(pool->ndirs, sizeof(Id));
1016 for (dn = 2, dirs = pool->dirs + dn; dn < pool->ndirs; dn++)
1030 if (!mptree[mp].child)
1035 comp = id2str(pool, id);
1036 compl = strlen(comp);
1037 for (i = mptree[mp].child; i; i = mptree[i].sibling)
1038 if (mptree[i].compl == compl && !strncmp(mptree[i].comp, comp, compl))
1040 dirmap[dn] = i ? i : -mp;
1042 /* change dirmap to point to mountpoint instead of mptree */
1043 for (dn = 0; dn < pool->ndirs; dn++)
1046 dirmap[i] = mptree[mp > 0 ? mp : -mp].mountpoint;
1049 cbdata.nmap = pool->ndirs;
1050 cbdata.dirmap = dirmap;
1052 md.callback = pool_fill_DU_add_cb;
1053 for_solvables_to_be_installed()
1055 if (p < data->start || p >= data->end)
1057 repodata_search(data, p - data->start, SOLVABLE_DUDATA, &md);
1059 md.callback = pool_fill_DU_sub_cb;
1060 for_solvables_to_be_erased()
1062 if (p < data->start || p >= data->end)
1064 repodata_search(data, p - data->start, SOLVABLE_DUDATA, &md);
1076 void pool_search(Pool *pool, Id p, Id key, const char *match, int flags, int (*callback)(void *cbdata, Solvable *s, struct _Repodata *data, struct _Repokey *key, struct _KeyValue *kv), void *cbdata)
1080 if (pool->solvables[p].repo)
1081 repo_search(pool->solvables[p].repo, p, key, match, flags, callback, cbdata);
1084 /* FIXME: obey callback return value! */
1085 for (p = 1; p < pool->nsolvables; p++)
1086 if (pool->solvables[p].repo)
1087 repo_search(pool->solvables[p].repo, p, key, match, flags, callback, cbdata);