← Back to branch summary

~ubuntu-branches/ubuntu/vivid/lvm2/vivid

« back to all changes in this revision

Viewing changes to lib/format1/disk-rep.c

  • Committer: Package Import Robot
  • Author(s): Bastian Blank
  • Date: 2012-05-01 20:27:50 UTC
  • mto: (3.1.23 sid)
  • mto: This revision was merged to the branch mainline in revision 72.
  • Revision ID: package-import@ubuntu.com-20120501202750-gljjjtblowwq9mw8
Tags: upstream-2.02.95
Import upstream version 2.02.95

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/format1/disk-rep.c
335
335
                return;
336
336
        }
337
337
 
338
 
        info->device_size = xlate32(dl->pvd.pv_size) << SECTOR_SHIFT;
339
 
        dm_list_init(&info->mdas);
340
 
        info->status &= ~CACHE_INVALID;
 
338
        lvmcache_set_device_size(info, xlate32(dl->pvd.pv_size) << SECTOR_SHIFT);
 
339
        lvmcache_del_mdas(info);
 
340
        lvmcache_make_valid(info);
341
341
}
342
342
 
343
343
static struct disk_list *__read_disk(const struct format_type *fmt,
451
451
        dm_list_add(head, &data->list);
452
452
}
453
453
 
 
454
struct _read_pvs_in_vg_baton {
 
455
        const char *vg_name;
 
456
        struct dm_list *head;
 
457
        struct disk_list *data;
 
458
        struct dm_pool *mem;
 
459
        int empty;
 
460
};
 
461
 
 
462
static int _read_pv_in_vg(struct lvmcache_info *info, void *baton)
 
463
{
 
464
        struct _read_pvs_in_vg_baton *b = baton;
 
465
 
 
466
        b->empty = 0;
 
467
 
 
468
        if (!lvmcache_device(info) ||
 
469
            !(b->data = read_disk(lvmcache_fmt(info), lvmcache_device(info), b->mem, b->vg_name)))
 
470
                return 0; /* stop here */
 
471
 
 
472
        _add_pv_to_list(b->head, b->data);
 
473
        return 1;
 
474
}
 
475
 
454
476
/*
455
477
 * Build a list of pv_d's structures, allocated from mem.
456
478
 * We keep track of the first object allocated from the pool
462
484
{
463
485
        struct dev_iter *iter;
464
486
        struct device *dev;
465
 
        struct disk_list *data = NULL;
466
487
        struct lvmcache_vginfo *vginfo;
467
 
        struct lvmcache_info *info;
 
488
        struct _read_pvs_in_vg_baton baton;
 
489
 
 
490
        baton.head = head;
 
491
        baton.empty = 1;
 
492
        baton.data = NULL;
 
493
        baton.mem = mem;
 
494
        baton.vg_name = vg_name;
468
495
 
469
496
        /* Fast path if we already saw this VG and cached the list of PVs */
470
 
        if (vg_name && (vginfo = vginfo_from_vgname(vg_name, NULL)) &&
471
 
            vginfo->infos.n) {
472
 
                dm_list_iterate_items(info, &vginfo->infos) {
473
 
                        dev = info->dev;
474
 
                        if (!dev || !(data = read_disk(fmt, dev, mem, vg_name)))
475
 
                                break;
476
 
                        _add_pv_to_list(head, data);
 
497
        if (vg_name && (vginfo = lvmcache_vginfo_from_vgname(vg_name, NULL))) {
 
498
 
 
499
                lvmcache_foreach_pv(vginfo, _read_pv_in_vg, &baton);
 
500
 
 
501
                if (!baton.empty) {
 
502
                        /* Did we find the whole VG? */
 
503
                        if (!vg_name || is_orphan_vg(vg_name) ||
 
504
                            (baton.data && *baton.data->pvd.vg_name &&
 
505
                             dm_list_size(head) == baton.data->vgd.pv_cur))
 
506
                                return 1;
 
507
 
 
508
                        /* Failed */
 
509
                        dm_list_init(head);
 
510
                        /* vgcache_del(vg_name); */
477
511
                }
478
 
 
479
 
                /* Did we find the whole VG? */
480
 
                if (!vg_name || is_orphan_vg(vg_name) ||
481
 
                    (data && *data->pvd.vg_name &&
482
 
                     dm_list_size(head) == data->vgd.pv_cur))
483
 
                        return 1;
484
 
 
485
 
                /* Failed */
486
 
                dm_list_init(head);
487
 
                /* vgcache_del(vg_name); */
488
512
        }
489
513
 
490
514
        if (!(iter = dev_iter_create(filter, 1))) {
494
518
 
495
519
        /* Otherwise do a complete scan */
496
520
        for (dev = dev_iter_get(iter); dev; dev = dev_iter_get(iter)) {
497
 
                if ((data = read_disk(fmt, dev, mem, vg_name))) {
498
 
                        _add_pv_to_list(head, data);
 
521
                if ((baton.data = read_disk(fmt, dev, mem, vg_name))) {
 
522
                        _add_pv_to_list(head, baton.data);
499
523
                }
500
524
        }
501
525
        dev_iter_destroy(iter);