1
2 #include "fdiskP.h"
3
4 /**
5 * SECTION: table
6 * @title: Table
7 * @short_description: container for fdisk partitions
8 *
9 * The fdisk_table is simple container for fdisk_partitions. The table is no
10 * directly connected to label data (partition table), and table changes don't
11 * affect in-memory or on-disk data.
12 */
13
14 /**
15 * fdisk_new_table:
16 *
17 * The table is a container for struct fdisk_partition entries. The container
18 * does not have any real connection with label (partition table) and with
19 * real on-disk data.
20 *
21 * Returns: newly allocated table struct.
22 */
23 struct fdisk_table *fdisk_new_table(void)
24 {
25 struct fdisk_table *tb = NULL;
26
27 tb = calloc(1, sizeof(*tb));
28 if (!tb)
29 return NULL;
30
31 DBG(TAB, ul_debugobj(tb, "alloc"));
32 tb->refcount = 1;
33 INIT_LIST_HEAD(&tb->parts);
34 return tb;
35 }
36
37 /**
38 * fdisk_reset_table:
39 * @tb: tab pointer
40 *
41 * Removes all entries (partitions) from the table. The partitions with zero
42 * reference count will be deallocated. This function does not modify partition
43 * table.
44 *
45 * Returns: 0 on success or negative number in case of error.
46 */
47 int fdisk_reset_table(struct fdisk_table *tb)
48 {
49 if (!tb)
50 return -EINVAL;
51
52 DBG(TAB, ul_debugobj(tb, "reset"));
53
54 while (!list_empty(&tb->parts)) {
55 struct fdisk_partition *pa = list_entry(tb->parts.next,
56 struct fdisk_partition, parts);
57 fdisk_table_remove_partition(tb, pa);
58 }
59
60 tb->nents = 0;
61 return 0;
62 }
63
64 /**
65 * fdisk_ref_table:
66 * @tb: table pointer
67 *
68 * Increments reference counter.
69 */
70 void fdisk_ref_table(struct fdisk_table *tb)
71 {
72 if (tb)
73 tb->refcount++;
74 }
75
76 /**
77 * fdisk_unref_table:
78 * @tb: table pointer
79 *
80 * Descrements reference counter, on zero the @tb is automatically
81 * deallocated.
82 */
83 void fdisk_unref_table(struct fdisk_table *tb)
84 {
85 if (!tb)
86 return;
87
88 tb->refcount--;
89 if (tb->refcount <= 0) {
90 fdisk_reset_table(tb);
91
92 DBG(TAB, ul_debugobj(tb, "free"));
93 free(tb);
94 }
95 }
96
97 /**
98 * fdisk_table_is_empty:
99 * @tb: pointer to tab
100 *
101 * Returns: 1 if the table is without filesystems, or 0.
102 */
103 int fdisk_table_is_empty(struct fdisk_table *tb)
104 {
105 return tb == NULL || list_empty(&tb->parts) ? 1 : 0;
106 }
107
108 /**
109 * fdisk_table_get_nents:
110 * @tb: pointer to tab
111 *
112 * Returns: number of entries in table.
113 */
114 size_t fdisk_table_get_nents(struct fdisk_table *tb)
115 {
116 return tb ? tb->nents : 0;
117 }
118
119 /**
120 * fdisk_table_next_partition:
121 * @tb: tab pointer
122 * @itr: iterator
123 * @pa: returns the next tab entry
124 *
125 * Returns: 0 on success, negative number in case of error or 1 at the end of list.
126 *
127 * Example:
128 * <informalexample>
129 * <programlisting>
130 * while(fdisk_table_next_partition(tb, itr, &pa) == 0) {
131 * ...
132 * }
133 * </programlisting>
134 * </informalexample>
135 */
136 int fdisk_table_next_partition(
137 struct fdisk_table *tb,
138 struct fdisk_iter *itr,
139 struct fdisk_partition **pa)
140 {
141 int rc = 1;
142
143 if (!tb || !itr || !pa)
144 return -EINVAL;
145 *pa = NULL;
146
147 if (!itr->head)
148 FDISK_ITER_INIT(itr, &tb->parts);
149 if (itr->p != itr->head) {
150 FDISK_ITER_ITERATE(itr, *pa, struct fdisk_partition, parts);
151 rc = 0;
152 }
153
154 return rc;
155 }
156
157 /**
158 * fdisk_table_get_partition:
159 * @tb: tab pointer
160 * @n: number of entry in table
161 *
162 * Returns: n-th entry from table or NULL
163 */
164 struct fdisk_partition *fdisk_table_get_partition(
165 struct fdisk_table *tb,
166 size_t n)
167 {
168 struct fdisk_partition *pa = NULL;
169 struct fdisk_iter itr;
170
171 if (!tb)
172 return NULL;
173
174 fdisk_reset_iter(&itr, FDISK_ITER_FORWARD);
175
176 while (fdisk_table_next_partition(tb, &itr, &pa) == 0) {
177 if (n == 0)
178 return pa;
179 n--;
180 }
181
182 return NULL;
183 }
184
185 /**
186 * fdisk_table_get_partition_by_partno:
187 * @tb: tab pointer
188 * @partno: partition number
189 *
190 * Returns: partition with @partno or NULL.
191 */
192 struct fdisk_partition *fdisk_table_get_partition_by_partno(
193 struct fdisk_table *tb,
194 size_t partno)
195 {
196 struct fdisk_partition *pa = NULL;
197 struct fdisk_iter itr;
198
199 if (!tb)
200 return NULL;
201
202 fdisk_reset_iter(&itr, FDISK_ITER_FORWARD);
203
204 while (fdisk_table_next_partition(tb, &itr, &pa) == 0) {
205 if (pa->partno == partno)
206 return pa;
207 }
208
209 return NULL;
210 }
211
212 /**
213 * fdisk_table_add_partition
214 * @tb: tab pointer
215 * @pa: new entry
216 *
217 * Adds a new entry to table and increment @pa reference counter. Don't forget to
218 * use fdisk_unref_partition() after fdisk_table_add_partition() if you want to keep
219 * the @pa referenced by the table only.
220 *
221 * Returns: 0 on success or negative number in case of error.
222 */
223 int fdisk_table_add_partition(struct fdisk_table *tb, struct fdisk_partition *pa)
224 {
225 if (!tb || !pa)
226 return -EINVAL;
227
228 if (!list_empty(&pa->parts))
229 return -EBUSY;
230
231 fdisk_ref_partition(pa);
232 list_add_tail(&pa->parts, &tb->parts);
233 tb->nents++;
234
235 DBG(TAB, ul_debugobj(tb, "add entry %p [start=%ju, end=%ju, size=%ju, %s %s %s]",
236 pa,
237 (uintmax_t) fdisk_partition_get_start(pa),
238 fdisk_partition_has_end(pa) ? (uintmax_t) fdisk_partition_get_end(pa) : 0,
239 fdisk_partition_has_size(pa) ? (uintmax_t) fdisk_partition_get_size(pa) : 0,
240 fdisk_partition_is_freespace(pa) ? "freespace" : "",
241 fdisk_partition_is_nested(pa) ? "nested" : "",
242 fdisk_partition_is_container(pa) ? "container" : "primary"));
243 return 0;
244 }
245
246 /* inserts @pa after @poz */
247 static int table_insert_partition(
248 struct fdisk_table *tb,
249 struct fdisk_partition *poz,
250 struct fdisk_partition *pa)
251 {
252 assert(tb);
253 assert(pa);
254
255 fdisk_ref_partition(pa);
256 if (poz)
257 list_add(&pa->parts, &poz->parts);
258 else
259 list_add(&pa->parts, &tb->parts);
260 tb->nents++;
261
262 DBG(TAB, ul_debugobj(tb, "insert entry %p pre=%p [start=%ju, end=%ju, size=%ju, %s %s %s]",
263 pa, poz ? poz : NULL,
264 (uintmax_t) fdisk_partition_get_start(pa),
265 (uintmax_t) fdisk_partition_get_end(pa),
266 (uintmax_t) fdisk_partition_get_size(pa),
267 fdisk_partition_is_freespace(pa) ? "freespace" : "",
268 fdisk_partition_is_nested(pa) ? "nested" : "",
269 fdisk_partition_is_container(pa) ? "container" : ""));
270 return 0;
271 }
272
273 /**
274 * fdisk_table_remove_partition
275 * @tb: tab pointer
276 * @pa: new entry
277 *
278 * Removes the @pa from the table and de-increment reference counter of the @pa. The
279 * partition with zero reference counter will be deallocated. Don't forget to use
280 * fdisk_ref_partition() before call fdisk_table_remove_partition() if you want
281 * to use @pa later.
282 *
283 * Returns: 0 on success or negative number in case of error.
284 */
285 int fdisk_table_remove_partition(struct fdisk_table *tb, struct fdisk_partition *pa)
286 {
287 if (!tb || !pa)
288 return -EINVAL;
289
290 DBG(TAB, ul_debugobj(tb, "remove entry %p", pa));
291 list_del(&pa->parts);
292 INIT_LIST_HEAD(&pa->parts);
293
294 fdisk_unref_partition(pa);
295 tb->nents--;
296
297 return 0;
298 }
299
300 /**
301 * fdisk_get_partitions
302 * @cxt: fdisk context
303 * @tb: returns table
304 *
305 * This function adds partitions from disklabel to @table, it allocates a new
306 * table if @table points to NULL.
307 *
308 * Returns: 0 on success, otherwise, a corresponding error.
309 */
310 int fdisk_get_partitions(struct fdisk_context *cxt, struct fdisk_table **tb)
311 {
312 size_t i;
313
314 if (!cxt || !cxt->label || !tb)
315 return -EINVAL;
316 if (!cxt->label->op->get_part)
317 return -ENOSYS;
318
319 DBG(CXT, ul_debugobj(cxt, " -- get table --"));
320
321 if (!*tb && !(*tb = fdisk_new_table()))
322 return -ENOMEM;
323
324 for (i = 0; i < cxt->label->nparts_max; i++) {
325 struct fdisk_partition *pa = NULL;
326
327 if (fdisk_get_partition(cxt, i, &pa) != 0)
328 continue;
329 if (fdisk_partition_is_used(pa))
330 fdisk_table_add_partition(*tb, pa);
331 fdisk_unref_partition(pa);
332 }
333
334 return 0;
335 }
336
337 void fdisk_debug_print_table(struct fdisk_table *tb)
338 {
339 struct fdisk_iter itr;
340 struct fdisk_partition *pa;
341
342 fdisk_reset_iter(&itr, FDISK_ITER_FORWARD);
343 while (fdisk_table_next_partition(tb, &itr, &pa) == 0)
344 ul_debugobj(tb, "partition %p [partno=%zu, start=%ju, end=%ju, size=%ju%s%s%s] ",
345 pa, pa->partno,
346 (uintmax_t) fdisk_partition_get_start(pa),
347 (uintmax_t) fdisk_partition_get_end(pa),
348 (uintmax_t) fdisk_partition_get_size(pa),
349 fdisk_partition_is_nested(pa) ? " nested" : "",
350 fdisk_partition_is_freespace(pa) ? " freespace" : "",
351 fdisk_partition_is_container(pa) ? " container" : "");
352
353 }
354
355
356 typedef int (*fdisk_partcmp_t)(struct fdisk_partition *, struct fdisk_partition *);
357
358 static int cmp_parts_wrapper(struct list_head *a, struct list_head *b, void *data)
359 {
360 struct fdisk_partition *pa = list_entry(a, struct fdisk_partition, parts),
361 *pb = list_entry(b, struct fdisk_partition, parts);
362
363 fdisk_partcmp_t cmp = (fdisk_partcmp_t) data;
364
365 return cmp(pa, pb);
366 }
367
368
369 /**
370 * fdisk_table_sort_partitions:
371 * @tb: table
372 * @cmp: compare function
373 *
374 * Sort partition in the table.
375 *
376 * Returns: 0 on success, <0 on error.
377 */
378 int fdisk_table_sort_partitions(struct fdisk_table *tb,
379 int (*cmp)(struct fdisk_partition *,
380 struct fdisk_partition *))
381 {
382 if (!tb)
383 return -EINVAL;
384
385 /*
386 DBG(TAB, ul_debugobj(tb, "Before sort:"));
387 ON_DBG(TAB, fdisk_debug_print_table(tb));
388 */
389
390 list_sort(&tb->parts, cmp_parts_wrapper, (void *) cmp);
391
392 /*
393 DBG(TAB, ul_debugobj(tb, "After sort:"));
394 ON_DBG(TAB, fdisk_debug_print_table(tb));
395 */
396
397 return 0;
398 }
399
400 /* allocates a new freespace description */
401 static int new_freespace(struct fdisk_context *cxt,
402 fdisk_sector_t start,
403 fdisk_sector_t end,
404 struct fdisk_partition *parent,
405 struct fdisk_partition **pa)
406 {
407 fdisk_sector_t aligned_start, size;
408
409 assert(cxt);
410 assert(pa);
411
412 *pa = NULL;
413
414 if (start == end)
415 return 0;
416
417 assert(start >= cxt->first_lba);
418 assert(end);
419 assert(end > start);
420
421 aligned_start = fdisk_align_lba_in_range(cxt, start, start, end);
422 size = end - aligned_start + 1ULL;
423
424 if (size == 0) {
425 DBG(TAB, ul_debug("ignore freespace (aligned size is zero)"));
426 return 0;
427 }
428
429 *pa = fdisk_new_partition();
430 if (!*pa)
431 return -ENOMEM;
432
433 (*pa)->freespace = 1;
434 (*pa)->start = aligned_start;
435 (*pa)->size = size;
436
437 if (parent)
438 (*pa)->parent_partno = parent->partno;
439 return 0;
440 }
441
442 /* add freespace description to the right place within @tb */
443 static int table_add_freespace(
444 struct fdisk_context *cxt,
445 struct fdisk_table *tb,
446 fdisk_sector_t start,
447 fdisk_sector_t end,
448 struct fdisk_partition *parent)
449 {
450 struct fdisk_partition *pa, *x, *real_parent = NULL, *best = NULL;
451 struct fdisk_iter itr;
452 int rc = 0;
453
454 assert(tb);
455
456 rc = new_freespace(cxt, start, end, parent, &pa);
457 if (rc)
458 return -ENOMEM;
459 if (!pa)
460 return 0;
461
462 assert(fdisk_partition_has_start(pa));
463 assert(fdisk_partition_has_end(pa));
464
465 DBG(TAB, ul_debugobj(tb, "adding freespace"));
466
467 fdisk_reset_iter(&itr, FDISK_ITER_FORWARD);
468 if (parent && fdisk_partition_has_partno(parent)) {
469 while (fdisk_table_next_partition(tb, &itr, &x) == 0) {
470 if (!fdisk_partition_has_partno(x))
471 continue;
472 if (x->partno == parent->partno) {
473 real_parent = x;
474 break;
475 }
476 }
477 if (!real_parent) {
478 DBG(TAB, ul_debugobj(tb, "not found freespace parent (partno=%zu)",
479 parent->partno));
480 fdisk_reset_iter(&itr, FDISK_ITER_FORWARD);
481 }
482 }
483
484 while (fdisk_table_next_partition(tb, &itr, &x) == 0) {
485 fdisk_sector_t the_end, best_end = 0;
486
487 if (!fdisk_partition_has_end(x))
488 continue;
489
490 the_end = fdisk_partition_get_end(x);
491 if (best)
492 best_end = fdisk_partition_get_end(best);
493
494 if (the_end < pa->start && (!best || best_end < the_end))
495 best = x;
496 }
497
498 if (!best && real_parent)
499 best = real_parent;
500 rc = table_insert_partition(tb, best, pa);
501
502 fdisk_unref_partition(pa);
503
504 DBG(TAB, ul_debugobj(tb, "adding freespace DONE [rc=%d]", rc));
505 return rc;
506 }
507
508 /* analyze @cont(ainer) in @parts and add all detected freespace into @tb, note
509 * that @parts has to be sorted by partition starts */
510 static int check_container_freespace(struct fdisk_context *cxt,
511 struct fdisk_table *parts,
512 struct fdisk_table *tb,
513 struct fdisk_partition *cont)
514 {
515 struct fdisk_iter itr;
516 struct fdisk_partition *pa;
517 fdisk_sector_t x, last, grain, lastplusoff;
518 int rc = 0;
519
520 assert(cxt);
521 assert(parts);
522 assert(tb);
523 assert(cont);
524 assert(fdisk_partition_has_start(cont));
525
526 DBG(TAB, ul_debugobj(tb, "analyze container 0x%p", cont));
527
528 last = fdisk_partition_get_start(cont);
529 grain = cxt->grain > cxt->sector_size ? cxt->grain / cxt->sector_size : 1;
530 fdisk_reset_iter(&itr, FDISK_ITER_FORWARD);
531
532 DBG(CXT, ul_debugobj(cxt, "initialized: last=%ju, grain=%ju",
533 (uintmax_t)last, (uintmax_t)grain));
534
535 while (fdisk_table_next_partition(parts, &itr, &pa) == 0) {
536
537 DBG(CXT, ul_debugobj(cxt, "partno=%zu, start=%ju",
538 pa->partno, (uintmax_t)pa->start));
539
540 if (!pa->used || !fdisk_partition_is_nested(pa)
541 || !fdisk_partition_has_start(pa))
542 continue;
543
544 DBG(CXT, ul_debugobj(cxt, "freespace container analyze: partno=%zu, start=%ju, end=%ju",
545 pa->partno,
546 (uintmax_t) fdisk_partition_get_start(pa),
547 (uintmax_t) fdisk_partition_get_end(pa)));
548
549 lastplusoff = last + cxt->first_lba;
550 if (pa->start > lastplusoff && pa->start - lastplusoff > grain)
551 rc = table_add_freespace(cxt, tb, lastplusoff, pa->start, cont);
552 if (rc)
553 goto done;
554 last = fdisk_partition_get_end(pa);
555 }
556
557 /* free-space remaining in extended partition */
558 x = fdisk_partition_get_start(cont) + fdisk_partition_get_size(cont) - 1;
559 lastplusoff = last + cxt->first_lba;
560 if (lastplusoff < x && x - lastplusoff > grain) {
561 DBG(TAB, ul_debugobj(tb, "add remaining space in container 0x%p", cont));
562 rc = table_add_freespace(cxt, tb, lastplusoff, x, cont);
563 }
564
565 done:
566 DBG(TAB, ul_debugobj(tb, "analyze container 0x%p DONE [rc=%d]", cont, rc));
567 return rc;
568 }
569
570
571 /**
572 * fdisk_get_freespaces
573 * @cxt: fdisk context
574 * @tb: returns table
575 *
576 * This function adds freespace (described by fdisk_partition) to @table, it
577 * allocates a new table if the @table points to NULL.
578 *
579 * Note that free space smaller than grain (see fdisk_get_grain_size()) is
580 * ignored.
581 *
582 * Returns: 0 on success, otherwise, a corresponding error.
583 */
584 int fdisk_get_freespaces(struct fdisk_context *cxt, struct fdisk_table **tb)
585 {
586 int rc = 0;
587 size_t nparts = 0;
588 fdisk_sector_t last, grain;
589 struct fdisk_table *parts = NULL;
590 struct fdisk_partition *pa;
591 struct fdisk_iter itr;
592
593 DBG(CXT, ul_debugobj(cxt, "-- get freespace --"));
594
595 if (!cxt || !cxt->label || !tb)
596 return -EINVAL;
597 if (!*tb && !(*tb = fdisk_new_table()))
598 return -ENOMEM;
599
600 rc = fdisk_get_partitions(cxt, &parts);
601 if (rc)
602 goto done;
603
604 fdisk_table_sort_partitions(parts, fdisk_partition_cmp_start);
605 fdisk_reset_iter(&itr, FDISK_ITER_FORWARD);
606 last = cxt->first_lba;
607 grain = cxt->grain > cxt->sector_size ? cxt->grain / cxt->sector_size : 1;
608
609 DBG(CXT, ul_debugobj(cxt, "initialized: last=%ju, grain=%ju",
610 (uintmax_t)last, (uintmax_t)grain));
611
612 /* analyze gaps between partitions */
613 while (rc == 0 && fdisk_table_next_partition(parts, &itr, &pa) == 0) {
614
615 DBG(CXT, ul_debugobj(cxt, "partno=%zu, start=%ju",
616 pa->partno, (uintmax_t)pa->start));
617
618 if (!pa->used || pa->wholedisk || fdisk_partition_is_nested(pa)
619 || !fdisk_partition_has_start(pa))
620 continue;
621 DBG(CXT, ul_debugobj(cxt, "freespace analyze: partno=%zu, start=%ju, end=%ju",
622 pa->partno,
623 (uintmax_t) fdisk_partition_get_start(pa),
624 (uintmax_t) fdisk_partition_get_end(pa)));
625
626 /* We ignore small free spaces (smaller than grain) to keep partitions
627 * aligned, the exception is space before the first partition when
628 * cxt->first_lba is aligned. */
629 if (last + grain < pa->start
630 || (nparts == 0 &&
631 (fdisk_align_lba(cxt, last, FDISK_ALIGN_UP) <
632 pa->start))) {
633 rc = table_add_freespace(cxt, *tb,
634 last + (nparts == 0 ? 0 : 1),
635 pa->start - 1, NULL);
636 }
637 /* add gaps between logical partitions */
638 if (fdisk_partition_is_container(pa))
639 rc = check_container_freespace(cxt, parts, *tb, pa);
640
641 if (fdisk_partition_has_end(pa)) {
642 fdisk_sector_t pa_end = fdisk_partition_get_end(pa);
643 if (pa_end > last)
644 last = fdisk_partition_get_end(pa);
645 }
646 nparts++;
647 }
648
649 /* add free-space behind last partition to the end of the table (so
650 * don't use table_add_freespace()) */
651 if (rc == 0 && last + grain < cxt->last_lba - 1) {
652 DBG(CXT, ul_debugobj(cxt, "freespace behind last partition detected"));
653 rc = new_freespace(cxt,
654 last + (last > cxt->first_lba || nparts ? 1 : 0),
655 cxt->last_lba, NULL, &pa);
656 if (pa) {
657 fdisk_table_add_partition(*tb, pa);
658 fdisk_unref_partition(pa);
659 }
660 }
661
662 done:
663 fdisk_unref_table(parts);
664
665 DBG(CXT, ul_debugobj(cxt, "get freespace DONE [rc=%d]", rc));
666 return rc;
667 }
668
669 /**
670 * fdisk_table_wrong_order:
671 * @tb: table
672 *
673 * Returns: 1 of the table is not in disk order
674 */
675 int fdisk_table_wrong_order(struct fdisk_table *tb)
676 {
677 struct fdisk_partition *pa;
678 struct fdisk_iter itr;
679 fdisk_sector_t last = 0;
680
681 DBG(TAB, ul_debugobj(tb, "wrong older check"));
682
683 fdisk_reset_iter(&itr, FDISK_ITER_FORWARD);
684 while (tb && fdisk_table_next_partition(tb, &itr, &pa) == 0) {
685 if (!fdisk_partition_has_start(pa) || fdisk_partition_is_wholedisk(pa))
686 continue;
687 if (pa->start < last)
688 return 1;
689 last = pa->start;
690 }
691 return 0;
692 }
693
694 /**
695 * fdisk_apply_table:
696 * @cxt: context
697 * @tb: table
698 *
699 * Add partitions from table @tb to the in-memory disk label. See
700 * fdisk_add_partition(), fdisk_delete_all_partitions(). The partitions
701 * that does not define start (or does not follow the default start)
702 * are ignored.
703 *
704 * Returns: 0 on success, <0 on error.
705 */
706 int fdisk_apply_table(struct fdisk_context *cxt, struct fdisk_table *tb)
707 {
708 struct fdisk_partition *pa;
709 struct fdisk_iter itr;
710 int rc = 0;
711
712 assert(cxt);
713 assert(tb);
714
715 DBG(TAB, ul_debugobj(tb, "applying to context %p", cxt));
716
717 fdisk_reset_iter(&itr, FDISK_ITER_FORWARD);
718 while (tb && fdisk_table_next_partition(tb, &itr, &pa) == 0) {
719 if (!fdisk_partition_has_start(pa) && !pa->start_follow_default)
720 continue;
721 rc = fdisk_add_partition(cxt, pa, NULL);
722 if (rc)
723 break;
724 }
725
726 return rc;
727 }
728
729 int fdisk_diff_tables(struct fdisk_table *a, struct fdisk_table *b,
730 struct fdisk_iter *itr,
731 struct fdisk_partition **res, int *change)
732 {
733 struct fdisk_partition *pa = NULL, *pb;
734 int rc = 1;
735
736 assert(itr);
737 assert(res);
738 assert(change);
739
740 DBG(TAB, ul_debugobj(a, "table diff [new table=%p]", b));
741
742 if (a && (itr->head == NULL || itr->head == &a->parts)) {
743 DBG(TAB, ul_debugobj(a, " scanning old table"));
744 do {
745 rc = fdisk_table_next_partition(a, itr, &pa);
746 if (rc != 0)
747 break;
748 } while (!fdisk_partition_has_partno(pa));
749 }
750
751 if (rc == 1 && b) {
752 DBG(TAB, ul_debugobj(a, " scanning new table"));
753 if (itr->head != &b->parts) {
754 DBG(TAB, ul_debugobj(a, " initialize to TAB=%p", b));
755 fdisk_reset_iter(itr, FDISK_ITER_FORWARD);
756 }
757
758 while (fdisk_table_next_partition(b, itr, &pb) == 0) {
759 if (!fdisk_partition_has_partno(pb))
760 continue;
761 if (a == NULL ||
762 fdisk_table_get_partition_by_partno(a, pb->partno) == NULL) {
763 DBG(TAB, ul_debugobj(a, " #%zu ADDED", pb->partno));
764 *change = FDISK_DIFF_ADDED;
765 *res = pb;
766 return 0;
767 }
768 }
769 }
770
771 if (rc) {
772 DBG(TAB, ul_debugobj(a, "table diff done [rc=%d]", rc));
773 return rc; /* error or done */
774 }
775
776 pb = fdisk_table_get_partition_by_partno(b, pa->partno);
777
778 if (!pb) {
779 DBG(TAB, ul_debugobj(a, " #%zu REMOVED", pa->partno));
780 *change = FDISK_DIFF_REMOVED;
781 *res = pa;
782 } else if (pb->start != pa->start) {
783 DBG(TAB, ul_debugobj(a, " #%zu MOVED", pb->partno));
784 *change = FDISK_DIFF_MOVED;
785 *res = pb;
786 } else if (pb->size != pa->size) {
787 DBG(TAB, ul_debugobj(a, " #%zu RESIZED", pb->partno));
788 *change = FDISK_DIFF_RESIZED;
789 *res = pb;
790 } else {
791 DBG(TAB, ul_debugobj(a, " #%zu UNCHANGED", pb->partno));
792 *change = FDISK_DIFF_UNCHANGED;
793 *res = pa;
794 }
795 return 0;
796 }
797