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.
22 #include "poolid_private.h"
28 // reset all whatprovides
31 pool_freewhatprovides(Pool *pool)
33 pool->whatprovides = xfree(pool->whatprovides);
34 pool->whatprovidesdata = xfree(pool->whatprovidesdata);
35 pool->whatprovidesdataoff = 0;
36 pool->whatprovidesdataleft = 0;
40 // list of string constants, so we can do pointer/Id instead of string comparison
41 // index into array matches ID_xxx constants in pool.h
43 static const char *initpool_data[] = {
54 "solvable:recommends",
56 "solvable:supplements",
59 "rpm:dbid", /* direct key into rpmdb */
60 "solvable:prereqmarker",
61 "solvable:filemarker",
62 "namespace:installed",
79 pool = (Pool *)xcalloc(1, sizeof(*pool));
81 stringpool_init (&pool->ss, initpool_data);
83 // pre-alloc space for a RelDep
84 pool->rels = (Reldep *)xcalloc(1 + REL_BLOCK, sizeof(Reldep));
87 // pre-alloc space for a Solvable
88 pool->solvables = (Solvable *)xcalloc(2, sizeof(Solvable));
90 queue_init(&pool->vendormap);
91 s = pool->solvables + SYSTEMSOLVABLE;
92 s->name = SYSTEM_SYSTEM;
93 s->arch = ARCH_NOARCH;
102 pool_free(Pool *pool)
106 pool_freewhatprovides(pool);
107 pool_freeidhashes(pool);
108 pool_freeallrepos(pool, 1);
109 xfree(pool->id2arch);
110 xfree(pool->solvables);
111 xfree(pool->ss.stringspace);
112 xfree(pool->ss.strings);
114 queue_free(&pool->vendormap);
115 for (i = 0; i < DEP2STRBUF; i++)
116 xfree(pool->dep2strbuf[i]);
121 static Pool *pool_shrink_whatprovides_sortcmp_data;
124 pool_shrink_whatprovides_sortcmp(const void *ap, const void *bp)
127 Pool *pool = pool_shrink_whatprovides_sortcmp_data;
129 oa = pool->whatprovides[*(Id *)ap];
130 ob = pool->whatprovides[*(Id *)bp];
132 return *(Id *)ap - *(Id *)bp;
137 da = pool->whatprovidesdata + oa;
138 db = pool->whatprovidesdata + ob;
140 if ((r = (*da++ - *db++)) != 0)
144 return *(Id *)ap - *(Id *)bp;
148 pool_shrink_whatprovides(Pool *pool)
152 Id lastid, *last, *dp, *lp;
156 if (pool->ss.nstrings < 3)
158 sorted = xmalloc2(pool->ss.nstrings, sizeof(Id));
159 for (id = 0; id < pool->ss.nstrings; id++)
161 pool_shrink_whatprovides_sortcmp_data = pool;
162 qsort(sorted + 1, pool->ss.nstrings - 1, sizeof(Id), pool_shrink_whatprovides_sortcmp);
165 for (i = 1; i < pool->ss.nstrings; i++)
168 o = pool->whatprovides[id];
169 if (o == 0 || o == 1)
171 dp = pool->whatprovidesdata + o;
185 pool->whatprovides[id] = -lastid;
189 last = pool->whatprovidesdata + o;
193 dp = pool->whatprovidesdata + 2;
194 for (id = 1; id < pool->ss.nstrings; id++)
196 o = pool->whatprovides[id];
197 if (o == 0 || o == 1)
204 pool->whatprovides[id] = pool->whatprovides[i];
207 lp = pool->whatprovidesdata + o;
210 pool->whatprovides[id] = dp - pool->whatprovidesdata;
211 while ((*dp++ = *lp++) != 0)
214 o = dp - pool->whatprovidesdata;
216 printf("shrunk whatprovidesdata from %d to %d\n", pool->whatprovidesdataoff, o);
217 if (pool->whatprovidesdataoff == o)
219 r = pool->whatprovidesdataoff - o;
220 pool->whatprovidesdataoff = o;
221 pool->whatprovidesdata = xrealloc(pool->whatprovidesdata, (o + pool->whatprovidesdataleft) * sizeof(Id));
222 if (r > pool->whatprovidesdataleft)
223 r = pool->whatprovidesdataleft;
224 memset(pool->whatprovidesdata + o, 0, r * sizeof(Id));
231 * create hashes over complete pool to ease lookups
236 pool_prepare(Pool *pool)
238 int i, num, np, extra;
243 Offset *whatprovides;
244 Id *whatprovidesdata, *d;
247 printf("number of solvables: %d\n", pool->nsolvables);
249 printf("number of ids: %d + %d\n", pool->ss.nstrings, pool->nrels);
251 pool_freeidhashes(pool);
252 pool_freewhatprovides(pool);
253 num = pool->ss.nstrings + pool->nrels;
254 whatprovides = (Offset *)xcalloc(num, sizeof(Offset));
256 /* count providers for each name */
257 for (i = 1; i < pool->nsolvables; i++)
260 s = pool->solvables + i;
263 if (!pool_installable(pool, s))
265 pp = s->repo->idarraydata + s->provides;
266 while ((id = *pp++) != ID_NULL)
270 Reldep *rd = GETRELDEP(pool, id);
273 whatprovides[id]++; /* inc count of providers */
277 off = 2; /* first entry is undef, second is empty list */
279 np = 0; /* number of names provided */
280 for (i = 0; i < num; i++, idp++)
283 if (!n) /* no providers */
285 *idp = off; /* move from counts to offsets into whatprovidesdata */
286 off += n + 1; /* make space for all providers + terminating ID_NULL */
287 np++; /* inc # of provider 'slots' */
291 printf("provide ids: %d\n", np);
292 extra = 2 * pool->nrels;
298 printf("provide space needed: %d + %d\n", off, extra);
300 /* alloc space for all providers + extra */
301 whatprovidesdata = (Id *)xcalloc(off + extra, sizeof(Id));
303 /* now fill data for all provides */
304 for (i = 1; i < pool->nsolvables; i++)
307 s = pool->solvables + i;
310 if (!pool_installable(pool, s))
313 /* for all provides of this solvable */
314 pp = s->repo->idarraydata + s->provides;
315 while ((id = *pp++) != 0)
319 Reldep *rd = GETRELDEP(pool, id);
322 d = whatprovidesdata + whatprovides[id]; /* offset into whatprovidesdata */
326 while (*d) /* find free slot */
331 if (pool->verbose) printf("duplicate entry for %s in package %s.%s\n", id2str(pool, id), id2str(pool, s->name), id2str(pool, s->arch));
336 *d = i; /* put solvable Id into data */
339 pool->whatprovides = whatprovides;
340 pool->whatprovidesdata = whatprovidesdata;
341 pool->whatprovidesdataoff = off;
342 pool->whatprovidesdataleft = extra;
343 pool_shrink_whatprovides(pool);
347 /******************************************************************************/
350 * pool_queuetowhatprovides
352 * on-demand filling of provider information
353 * move queue data into whatprovidesdata
355 * returns: Offset into whatprovides
359 pool_queuetowhatprovides(Pool *pool, Queue *q)
362 int count = q->count;
364 if (count == 0) /* queue empty -> ID_EMPTY */
367 /* extend whatprovidesdata if needed, +1 for ID_NULL-termination */
368 if (pool->whatprovidesdataleft < count + 1)
371 printf("growing provides hash data...\n");
372 pool->whatprovidesdata = (Id *)xrealloc(pool->whatprovidesdata, (pool->whatprovidesdataoff + count + 4096) * sizeof(Id));
373 pool->whatprovidesdataleft = count + 4096;
376 /* copy queue to next free slot */
377 off = pool->whatprovidesdataoff;
378 memcpy(pool->whatprovidesdata + pool->whatprovidesdataoff, q->elements, count * sizeof(Id));
380 /* adapt count and ID_NULL-terminate */
381 pool->whatprovidesdataoff += count;
382 pool->whatprovidesdata[pool->whatprovidesdataoff++] = ID_NULL;
383 pool->whatprovidesdataleft -= count + 1;
389 /******************************************************************************/
394 * add packages fulfilling the relation to whatprovides array
395 * no exact providers, do range match
400 pool_addrelproviders(Pool *pool, Id d)
402 Reldep *rd = GETRELDEP(pool, d);
408 int flags = rd->flags;
410 Id p, *pp, *pp2, *pp3;
412 d = GETRELID(pool, d);
413 queue_init_buffer(&plist, buf, sizeof(buf)/sizeof(*buf));
418 pp = GET_PROVIDESP(name, p);
419 pp2 = GET_PROVIDESP(evr, p);
420 while ((p = *pp++) != 0)
422 for (pp3 = pp2; *pp3;)
425 queue_push(&plist, p);
431 pp = GET_PROVIDESP(name, p);
432 while ((p = *pp++) != 0)
433 queue_push(&plist, p);
434 pp = GET_PROVIDESP(evr, p);
435 while ((p = *pp++) != 0)
436 queue_pushunique(&plist, p);
439 if (pool->nscallback)
441 p = pool->nscallback(pool, pool->nscallbackdata, name, evr);
445 pool->whatprovides[d] = p;
446 return pool->whatprovidesdata + p;
449 queue_push(&plist, SYSTEMSOLVABLE);
456 /* convert to whatprovides id */
459 printf("addrelproviders: what provides %s?\n", id2str(pool, name));
461 if (flags && flags < 8)
463 FOR_PROVIDES(p, pp, name)
467 printf("addrelproviders: checking package %s\n", id2str(pool, pool->p[p].name));
469 /* solvable p provides name in some rels */
470 pidp = pool->solvables[p].repo->idarraydata + pool->solvables[p].provides;
471 while ((pid = *pidp++) != 0)
477 break; /* yes, provides all versions */
479 continue; /* wrong provides name */
480 prd = GETRELDEP(pool, pid);
481 if (prd->name != name)
482 continue; /* wrong provides name */
483 /* right package, both deps are rels */
487 if (flags == 7 || pflags == 7)
488 break; /* included */
489 if ((pflags & flags & 5) != 0)
490 break; /* same direction, match */
494 if ((pflags & flags & 2) != 0)
495 break; /* both have =, match */
499 int f = flags == 5 ? 5 : flags == 2 ? pflags : (flags ^ 5) & (pflags | 5);
500 if ((f & (1 << (1 + evrcmp(pool, pevr, evr)))) != 0)
505 continue; /* no rel match */
506 queue_push(&plist, p);
508 /* make our system solvable provide all unknown rpmlib() stuff */
509 if (plist.count == 0 && !strncmp(id2str(pool, name), "rpmlib(", 7))
510 queue_push(&plist, SYSTEMSOLVABLE);
512 /* add providers to whatprovides */
514 if (pool->verbose) printf("addrelproviders: adding %d packages to %d\n", plist.count, d);
516 pool->whatprovides[d] = pool_queuetowhatprovides(pool, &plist);
519 return pool->whatprovidesdata + pool->whatprovides[d];