Class: LVM::Snapshot

Inherits:
Object
  • Object
show all
Includes:
Helpers
Defined in:
lib/lvm/snapshot.rb

Instance Method Summary collapse

Methods included from Helpers

#big_endian?, #dtohq, #htonq, #ntohq, #swap_longs

Constructor Details

#initialize(vg, lv) ⇒ Snapshot

Returns a new instance of Snapshot.



9
10
11
12
 
# File 'lib/lvm/snapshot.rb', line 9

def initialize(vg, lv)
  @vg = vg
  @lv = lv
end

Instance Method Details

#differences ⇒ Object

Return an array of ranges which are the bytes which are different between the origin and the snapshot.



16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/lvm/snapshot.rb', line 16

def differences
  @differences ||= begin
    # For a regular, old-skool snapshot, getting the differences is
    # pretty trivial -- just read through the snapshot metadata, and
    # the list of changed blocks is right there.
    #
    diff_block_list = []

    File.open(metadata_device, 'r') do |metafd|
      in_progress = true

      # The first chunk of the metadata LV is the header, which we
      # don't care for at all
      metafd.seek chunk_size, IO::SEEK_SET

      while in_progress
        # The snapshot on-disk format is a stream of <blocklist>, <blockdata>
        # sets; within each <blocklist>, it's little-endian 64-bit block
        # IDs -- the first is the location (chunk_size * offset) in the origin
        # LV that the data has been changed, the second is the location (again,
        # chunk_size * offset) in the metadata LV where the changed data is
        # being stored.
        (chunk_size / 16).times do
          origin_offset, snap_offset = metafd.read(16).unpack("QQ")
          origin_offset = dtohq(origin_offset)
          snap_offset   = dtohq(snap_offset)

          # A snapshot offset of 0 would point back to the metadata
          # device header, so that's clearly invalid -- hence it's the
          # "no more blocks" indicator.
          if snap_offset == 0
            in_progress = false
            break
          end

          diff_block_list << origin_offset
        end

        # We've read through a set of origin => data mappings; now we need
        # to take a giant leap over the data blocks that follow it.
        metafd.seek chunk_size * chunk_size / 16, IO::SEEK_CUR
      end
    end

    # Block-to-byte-range is pretty trivial, and we're done!
    diff_block_list.map do |b|
      ((b*chunk_size)..(((b+1)*chunk_size)-1))
    end

    # There is one optimisation we could make here that we haven't --
    # coalescing adjacent byte ranges into single larger ranges.  I haven't
    # done it for two reasons: Firstly, I don't have any idea how much of a
    # real-world benefit it would be, and secondly, I couldn't work out how
    # to do it elegantly.  So I punted.
  end
end

#origin ⇒ Object 



73
74
75
76
 
# File 'lib/lvm/snapshot.rb', line 73

def origin
  # Man old-skool snapshots are weird
  vgcfg.logical_volumes.values.find { |lv| lv.cow_store == @lv }.origin
end