Before a risky package upgrade you snapshot the Linux server's root-adjacent data volume with `lvcreate -s`. The upgrade goes badly and you want to roll back. What does `lvconvert --merge vg0/snap` do, and why might the rollback not take effect the moment the command returns?

## What a merge is A classic snapshot holds the *old* contents of every chunk that changed on the origin since creation. That is exactly the material needed to undo those changes. `lvconvert --merge vg0/snap` asks device-mapper to write those preserved chunks back over the origin, chunk by chunk, until the origin is byte-identical to its state at snapshot time. When the merge finishes, the snapshot has served its purpose and LVM removes it — you do not clean up afterwards, and you cannot merge the same snapshot twice. This makes "snapshot before the change, merge if it goes wrong" a genuine rollback primitive for upgrades, migrations and configuration changes on a single host, provided the change is confined to that volume. ## Why it may not start immediately Merging rewrites the origin underneath anything that has it open. A mounted filesystem has cached metadata and in-flight I/O that would be silently invalidated, so LVM refuses to begin while the origin is in use. Instead it flags the merge and tells you it will start on the next activation. The practical sequences are: - **A data volume:** stop the services using it, `umount` it, then `lvchange -an vg0/data` followed by `lvchange -ay vg0/data`. The merge begins on activation and you can watch it. - **A volume the running system depends on** (the root filesystem, or anything that cannot be unmounted live): issue the merge, then reboot. Early boot activates the volume and the merge starts there. This is why root-volume rollback via LVM is a reboot-shaped operation, not an online one. While a merge is running, the origin can be used: reads are satisfied correctly whether the chunk has been merged back yet or not. `lvs` shows the merging snapshot's usage draining toward zero — a straightforward progress indicator — and the origin's attribute string shows it as a merging origin. ``` $ lvconvert --merge vg0/data-snap Delaying merge since origin is open. Merging of snapshot vg0/data-snap will occur on next activation. $ umount /data && lvchange -an vg0/data && lvchange -ay vg0/data $ lvs -o lv_name,origin,lv_attr,data_percent vg0 ``` If you change your mind before the merge begins, `lvconvert --mergethin`'s classic counterpart can be cancelled by removing the snapshot with `lvremove`, which drops the pending merge along with it. ## What the rollback costs you Three consequences worth stating without being asked: 1. **Everything written since the snapshot is gone.** Not just the failed upgrade — logs, new records, anything the application accepted in the meantime. If the volume took real traffic during the attempt, a merge is a data-loss event that you are choosing deliberately. Copy off what you need first. 2. **The window is bounded by the copy-on-write area.** If the snapshot filled and was invalidated at any point, there is nothing to merge; the rollback plan evaporated quietly hours before you needed it. Check the snapshot is still valid before you rely on it, and size it for the whole change window. 3. **The scope is one volume.** A change that also touched a database on another volume, a remote service, or state outside the machine is not undone. LVM rollback is a block-level undo of one logical volume, and pairing it with anything distributed needs a plan of its own. ## Thin snapshots For a snapshot of a thin volume the operation is `lvconvert --mergethin vg0/thin-snap`. The mechanics differ underneath — instead of copying preserved chunks back, dm-thin repoints the origin's mapping tree at the snapshot's — so the merge is close to instantaneous rather than proportional to the amount changed. The same open-device restriction applies: the origin must not be in use when the merge takes effect, and the snapshot is consumed by the operation. ## The interview shape A strong answer covers three beats: what merge means (write the preserved old data back and delete the snapshot), why it defers (the origin cannot be open while it is rewritten, so it starts on the next activation — reboot for a root volume), and what it costs (all writes since the snapshot, and only for that one volume). Mentioning that an invalidated snapshot means no rollback at all is the detail that marks someone who has actually depended on this.