~ubuntu-branches/ubuntu/saucy/lvm2/saucy

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Dmitrijs Ledkovs
  • Date: 2012-08-14 14:35:57 UTC
  • mfrom: (3.1.25 sid)
  • Revision ID: package-import@ubuntu.com-20120814143557-93aill2tp3kf3o30
Tags: 2.02.95-4ubuntu1
* Merge from Debian unstable, remaining changes:
  - debian/patches/avoid-dev-block.patch: Prefer any other device name over
    names in /dev/block/ since lvm.conf won't handle this.
  - debian/rules:
    - copy .po file to .pot file for Rosetta (Ubuntu specific).
  - debian/{dmsetup,lvm2}-udeb.install:
    - install initramfs and udev hooks in udebs (Debian bug 504341).
  - auto-start VGs as their PVs are discovered (Ubuntu specific):
    - add debian/tree/lvm2/lib/udev/rules.d/85-lvm2.rules: use watershed plus
      the sledgehammer of vgscan/vgchange to turn on VGs as they come online.
    - debian/tree/lvm2/usr/share/initramfs-tools/scripts/hooks/lvm2:
      - add 85-lvm2.rules to the list of udev rules to copy.
      - depend on udev.
    - debian/control:
      - add versioned Depend on watershed in lvm2 for udev rules.
      - add Depends on watershed-udeb in lvm2-udeb for udev rules.
      - add versioned Depend/Breaks on udev in dmsetup for udev rules.
      - add Depend on initramfs-tools in dmsetup so system is not potentially
        rendered unbootable by out-of-order dpkg configuration.
    - debian/rules:
      - do not install local-top scripts since Ubuntu mounts root using udev.
      - do not install init scripts for lvm2, since udev starts LVM.
    - debian/lvm2.postinst: handle missing lvm2 init script.
    - debian/tree/dmsetup/lib/udev/rules.d/60-persistent-storage-dm.rules:
      watch dm devices for changes with inotify
  - add mountroot failure hooks to help fix bad boots (Debian bug 468115):
    - debian/tree/lvm2/usr/share/initramfs-tools/scripts/init-premount/lvm2
  - remaining changes to upstream event manager packages (Debian bug 514706):
    - debian/rules:
      - enable dmeventd during configure.
    - debian/dmeventd.{8,manpages}: install dmeventd files.
  - rename debian/clvm.defaults to debian/clvm.default so it is installed
    correctly.
  - debian/control: add dmsetup-udeb to libdevmapper1.02.1-udeb recommends.
  - debian/rules: make sure dmsetup and lvm2 initramfs-tools scripts are
    executable.  When the Ubuntu-specific ones are added with a patch,
    they may lose their executable bit.
  - Add and install clvmd resource agent
  - Add dependency on libudev-dev to libdevmapper-dev so that the .pc file
    works.
  - debian/{clvmd.ra,clvm.init}:
    - create /run/lvm if it doesn't exist.
  - debian/clvm.init:
    - exit 3 if not running on status action.
  - Call dh_installman so that our dmeventd manpage actually gets installed
  - Install the missing fsadm manpage.

 * libdevmapper-dev:
  - move .so symlinks and pkgconfig files to multiarched locations.
  - mark libdevmapper-dev M-A: same

 * libdevmapper-event1.02.1:
  - Add Breaks: dmeventd (<< 2.02.95-4ubuntu1) due to debian symbol rename

 * debian/lvm2.{preinst,postinst,postrm}:
  - Implement removal of obsolete /etc/init.d/lvm2 conffile, which
    should not have been re-introduced in Quantal.

 * Dropped Changes, included in Debian:
  - Mostly included packages for upstream event manager (Debian bug 514706).
  - debian/patches/rules-subdir.patch: removed as reordering will cause
    build failure with dmeventd.
  - debian/patches/libdm-event-static.patch: removed as other static libs
    aren't being built anymore either.
  - Update symbols for libdevmapper-event.
  - Update libdevmapper-event, dmeventd descriptions to match Debian
    boilerplate.

 * Disappeared Changes:
  - Don't install documentation in udebs. No diff found, but no docs are
    installed into udebs either.

 * Resurected Changes:
  - corrected dropping the wrong init script. Now clvm.init is shipped
    and lvm2.init is dropped in favor of udev rules as per original
    intention (LP: #1037033).

Show diffs side-by-side

added added

removed removed

Lines of Context:
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);