Imported Upstream version 0.6.20
[platform/upstream/libsolv.git] / src / diskusage.c
1 /*
2  * Copyright (c) 2007-2016, SUSE LLC
3  *
4  * This program is licensed under the BSD license, read LICENSE.BSD
5  * for further information
6  */
7
8 /*
9  * diskusage.c
10  *
11  * calculate needed space on partitions
12  */
13
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <stdarg.h>
17 #include <unistd.h>
18 #include <string.h>
19
20 #include "pool.h"
21 #include "poolarch.h"
22 #include "repo.h"
23 #include "util.h"
24 #include "bitmap.h"
25
26
27 struct mptree {
28   Id sibling;
29   Id child;
30   const char *comp;
31   int compl;
32   Id mountpoint;
33 };
34
35 struct ducbdata {
36   DUChanges *mps;
37   struct mptree *mptree;
38   int addsub;
39   int hasdu;
40
41   Id *dirmap;
42   int nmap;
43   Repodata *olddata;
44 };
45
46
47 static int
48 solver_fill_DU_cb(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *value)
49 {
50   struct ducbdata *cbd = cbdata;
51   Id mp;
52
53   if (data != cbd->olddata)
54     {
55       Id dn, mp, comp, *dirmap, *dirs;
56       int i, compl;
57       const char *compstr;
58       struct mptree *mptree;
59
60       /* create map from dir to mptree */
61       cbd->dirmap = solv_free(cbd->dirmap);
62       cbd->nmap = 0;
63       dirmap = solv_calloc(data->dirpool.ndirs, sizeof(Id));
64       mptree = cbd->mptree;
65       mp = 0;
66       for (dn = 2, dirs = data->dirpool.dirs + dn; dn < data->dirpool.ndirs; dn++)
67         {
68           comp = *dirs++;
69           if (comp <= 0)
70             {
71               mp = dirmap[-comp];
72               continue;
73             }
74           if (mp < 0)
75             {
76               /* unconnected */
77               dirmap[dn] = mp;
78               continue;
79             }
80           if (!mptree[mp].child)
81             {
82               dirmap[dn] = -mp;
83               continue;
84             }
85           if (data->localpool)
86             compstr = stringpool_id2str(&data->spool, comp);
87           else
88             compstr = pool_id2str(data->repo->pool, comp);
89           compl = strlen(compstr);
90           for (i = mptree[mp].child; i; i = mptree[i].sibling)
91             if (mptree[i].compl == compl && !strncmp(mptree[i].comp, compstr, compl))
92               break;
93           dirmap[dn] = i ? i : -mp;
94         }
95       /* change dirmap to point to mountpoint instead of mptree */
96       for (dn = 0; dn < data->dirpool.ndirs; dn++)
97         {
98           mp = dirmap[dn];
99           dirmap[dn] = mptree[mp > 0 ? mp : -mp].mountpoint;
100         }
101       cbd->dirmap = dirmap;
102       cbd->nmap = data->dirpool.ndirs;
103       cbd->olddata = data;
104     }
105   cbd->hasdu = 1;
106   if (value->id < 0 || value->id >= cbd->nmap)
107     return 0;
108   mp = cbd->dirmap[value->id];
109   if (mp < 0)
110     return 0;
111   if (cbd->addsub > 0)
112     {
113       cbd->mps[mp].kbytes += value->num;
114       cbd->mps[mp].files += value->num2;
115     }
116   else if (!(cbd->mps[mp].flags & DUCHANGES_ONLYADD))
117     {
118       cbd->mps[mp].kbytes -= value->num;
119       cbd->mps[mp].files -= value->num2;
120     }
121   return 0;
122 }
123
124 static void
125 propagate_mountpoints(struct mptree *mptree, int pos, Id mountpoint)
126 {
127   int i;
128   if (mptree[pos].mountpoint == -1)
129     mptree[pos].mountpoint = mountpoint;
130   else
131     mountpoint = mptree[pos].mountpoint;
132   for (i = mptree[pos].child; i; i = mptree[i].sibling)
133     propagate_mountpoints(mptree, i, mountpoint);
134 }
135
136 #define MPTREE_BLOCK 15
137
138 static struct mptree *
139 create_mptree(DUChanges *mps, int nmps)
140 {
141   int i, nmptree;
142   struct mptree *mptree;
143   int pos, compl;
144   int mp;
145   const char *p, *path, *compstr;
146
147   mptree = solv_extend_resize(0, 1, sizeof(struct mptree), MPTREE_BLOCK);
148
149   /* our root node */
150   mptree[0].sibling = 0;
151   mptree[0].child = 0;
152   mptree[0].comp = 0;
153   mptree[0].compl = 0;
154   mptree[0].mountpoint = -1;
155   nmptree = 1;
156
157   /* create component tree */
158   for (mp = 0; mp < nmps; mp++)
159     {
160       mps[mp].kbytes = 0;
161       mps[mp].files = 0;
162       pos = 0;
163       path = mps[mp].path;
164       while(*path == '/')
165         path++;
166       while (*path)
167         {
168           if ((p = strchr(path, '/')) == 0)
169             {
170               compstr = path;
171               compl = strlen(compstr);
172               path += compl;
173             }
174           else
175             {
176               compstr = path;
177               compl = p - path;
178               path = p + 1;
179               while(*path == '/')
180                 path++;
181             }
182           for (i = mptree[pos].child; i; i = mptree[i].sibling)
183             if (mptree[i].compl == compl && !strncmp(mptree[i].comp, compstr, compl))
184               break;
185           if (!i)
186             {
187               /* create new node */
188               mptree = solv_extend(mptree, nmptree, 1, sizeof(struct mptree), MPTREE_BLOCK);
189               i = nmptree++;
190               mptree[i].sibling = mptree[pos].child;
191               mptree[i].child = 0;
192               mptree[i].comp = compstr;
193               mptree[i].compl = compl;
194               mptree[i].mountpoint = -1;
195               mptree[pos].child = i;
196             }
197           pos = i;
198         }
199       mptree[pos].mountpoint = mp;
200     }
201
202   propagate_mountpoints(mptree, 0, mptree[0].mountpoint);
203
204 #if 0
205   for (i = 0; i < nmptree; i++)
206     {
207       printf("#%d sibling: %d\n", i, mptree[i].sibling);
208       printf("#%d child: %d\n", i, mptree[i].child);
209       printf("#%d comp: %s\n", i, mptree[i].comp);
210       printf("#%d compl: %d\n", i, mptree[i].compl);
211       printf("#%d mountpont: %d\n", i, mptree[i].mountpoint);
212     }
213 #endif
214
215   return mptree;
216 }
217
218 void
219 pool_calc_duchanges(Pool *pool, Map *installedmap, DUChanges *mps, int nmps)
220 {
221   struct mptree *mptree;
222   struct ducbdata cbd;
223   Solvable *s;
224   int i, sp;
225   Map ignoredu;
226   Repo *oldinstalled = pool->installed;
227   int haveonlyadd = 0;
228
229   map_init(&ignoredu, 0);
230   mptree = create_mptree(mps, nmps);
231
232   for (i = 0; i < nmps; i++)
233     if ((mps[i].flags & DUCHANGES_ONLYADD) != 0)
234       haveonlyadd = 1;
235   cbd.mps = mps;
236   cbd.dirmap = 0;
237   cbd.nmap = 0;
238   cbd.olddata = 0;
239   cbd.mptree = mptree;
240   cbd.addsub = 1;
241   for (sp = 1, s = pool->solvables + sp; sp < pool->nsolvables; sp++, s++)
242     {
243       if (!s->repo || (oldinstalled && s->repo == oldinstalled))
244         continue;
245       if (!MAPTST(installedmap, sp))
246         continue;
247       cbd.hasdu = 0;
248       repo_search(s->repo, sp, SOLVABLE_DISKUSAGE, 0, 0, solver_fill_DU_cb, &cbd);
249       if (!cbd.hasdu && oldinstalled)
250         {
251           Id op, opp;
252           int didonlyadd = 0;
253           /* no du data available, ignore data of all installed solvables we obsolete */
254           if (!ignoredu.size)
255             map_grow(&ignoredu, oldinstalled->end - oldinstalled->start);
256           FOR_PROVIDES(op, opp, s->name)
257             {
258               Solvable *s2 = pool->solvables + op;
259               if (!pool->implicitobsoleteusesprovides && s->name != s2->name)
260                 continue;
261               if (pool->implicitobsoleteusescolors && !pool_colormatch(pool, s, s2))
262                 continue;
263               if (op >= oldinstalled->start && op < oldinstalled->end)
264                 {
265                   MAPSET(&ignoredu, op - oldinstalled->start);
266                   if (haveonlyadd && pool->solvables[op].repo == oldinstalled && !didonlyadd)
267                     {
268                       repo_search(oldinstalled, op, SOLVABLE_DISKUSAGE, 0, 0, solver_fill_DU_cb, &cbd);
269                       cbd.addsub = -1;
270                       repo_search(oldinstalled, op, SOLVABLE_DISKUSAGE, 0, 0, solver_fill_DU_cb, &cbd);
271                       cbd.addsub = 1;
272                       didonlyadd = 1;
273                     }
274                 }
275             }
276           if (s->obsoletes)
277             {
278               Id obs, *obsp = s->repo->idarraydata + s->obsoletes;
279               while ((obs = *obsp++) != 0)
280                 FOR_PROVIDES(op, opp, obs)
281                   {
282                     Solvable *s2 = pool->solvables + op;
283                     if (!pool->obsoleteusesprovides && !pool_match_nevr(pool, s2, obs))
284                       continue;
285                     if (pool->obsoleteusescolors && !pool_colormatch(pool, s, s2))
286                       continue;
287                     if (op >= oldinstalled->start && op < oldinstalled->end)
288                       {
289                         MAPSET(&ignoredu, op - oldinstalled->start);
290                         if (haveonlyadd && pool->solvables[op].repo == oldinstalled && !didonlyadd)
291                           {
292                             repo_search(oldinstalled, op, SOLVABLE_DISKUSAGE, 0, 0, solver_fill_DU_cb, &cbd);
293                             cbd.addsub = -1;
294                             repo_search(oldinstalled, op, SOLVABLE_DISKUSAGE, 0, 0, solver_fill_DU_cb, &cbd);
295                             cbd.addsub = 1;
296                             didonlyadd = 1;
297                           }
298                       }
299                   }
300             }
301         }
302     }
303   cbd.addsub = -1;
304   if (oldinstalled)
305     {
306       /* assumes we allways have du data for installed solvables */
307       FOR_REPO_SOLVABLES(oldinstalled, sp, s)
308         {
309           if (MAPTST(installedmap, sp))
310             continue;
311           if (ignoredu.map && MAPTST(&ignoredu, sp - oldinstalled->start))
312             continue;
313           repo_search(oldinstalled, sp, SOLVABLE_DISKUSAGE, 0, 0, solver_fill_DU_cb, &cbd);
314         }
315     }
316   map_free(&ignoredu);
317   solv_free(cbd.dirmap);
318   solv_free(mptree);
319 }
320
321 int
322 pool_calc_installsizechange(Pool *pool, Map *installedmap)
323 {
324   Id sp;
325   Solvable *s;
326   int change = 0; 
327   Repo *oldinstalled = pool->installed;
328
329   for (sp = 1, s = pool->solvables + sp; sp < pool->nsolvables; sp++, s++) 
330     {    
331       if (!s->repo || (oldinstalled && s->repo == oldinstalled))
332         continue;
333       if (!MAPTST(installedmap, sp)) 
334         continue;
335       change += solvable_lookup_sizek(s, SOLVABLE_INSTALLSIZE, 0);
336     }    
337   if (oldinstalled)
338     {    
339       FOR_REPO_SOLVABLES(oldinstalled, sp, s)
340         {
341           if (MAPTST(installedmap, sp)) 
342             continue;
343           change -= solvable_lookup_sizek(s, SOLVABLE_INSTALLSIZE, 0);
344         }
345     }    
346   return change;
347 }
348