1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
// Copyright (C) 2022 Luke Shumaker <lukeshu@lukeshu.com>
//
// SPDX-License-Identifier: GPL-2.0-or-later
package rebuildmappings
import (
"context"
"fmt"
"github.com/datawire/dlib/dlog"
"git.lukeshu.com/btrfs-progs-ng/lib/btrfs"
"git.lukeshu.com/btrfs-progs-ng/lib/btrfs/btrfsvol"
"git.lukeshu.com/btrfs-progs-ng/lib/btrfsprogs/btrfsinspect"
"git.lukeshu.com/btrfs-progs-ng/lib/containers"
"git.lukeshu.com/btrfs-progs-ng/lib/maps"
)
func getNodeSize(fs *btrfs.FS) (btrfsvol.AddrDelta, error) {
sb, err := fs.Superblock()
if err != nil {
return 0, err
}
return btrfsvol.AddrDelta(sb.NodeSize), nil
}
func RebuildMappings(ctx context.Context, fs *btrfs.FS, scanResults btrfsinspect.ScanDevicesResult) error {
nodeSize, err := getNodeSize(fs)
if err != nil {
return err
}
var numChunks, numDevExts, numBlockGroups, numNodes int
devIDs := maps.SortedKeys(scanResults)
devices := fs.LV.PhysicalVolumes()
for _, devID := range devIDs {
if _, ok := devices[devID]; !ok {
return fmt.Errorf("device ID %v mentioned in scan results is not part of the filesystem", devID)
}
devResults := scanResults[devID]
numChunks += len(devResults.FoundChunks)
numDevExts += len(devResults.FoundDevExtents)
numBlockGroups += len(devResults.FoundBlockGroups)
for _, paddrs := range devResults.FoundNodes {
numNodes += len(paddrs)
}
}
dlog.Infof(ctx, "plan: 1/5 process %d chunks", numChunks)
dlog.Infof(ctx, "plan: 2/5 process %d device extents", numDevExts)
dlog.Infof(ctx, "plan: 3/5 process %d nodes", numNodes)
dlog.Infof(ctx, "plan: 4/5 process %d block groups", numBlockGroups)
dlog.Infof(ctx, "plan: 5/5 process sums")
dlog.Infof(ctx, "1/5: Processing %d chunks...", numChunks)
for _, devID := range devIDs {
devResults := scanResults[devID]
for _, chunk := range devResults.FoundChunks {
for _, mapping := range chunk.Chunk.Mappings(chunk.Key) {
if err := fs.LV.AddMapping(mapping); err != nil {
dlog.Errorf(ctx, "... error: adding chunk: %v", err)
}
}
}
}
dlog.Info(ctx, "... done processing chunks")
dlog.Infof(ctx, "2/5: Processing %d device extents...", numDevExts)
for _, devID := range devIDs {
devResults := scanResults[devID]
for _, ext := range devResults.FoundDevExtents {
if err := fs.LV.AddMapping(ext.DevExt.Mapping(ext.Key)); err != nil {
dlog.Errorf(ctx, "... error: adding devext: %v", err)
}
}
}
dlog.Info(ctx, "... done processing device extents")
// Do the nodes "last" to avoid bloating the mappings table
// too much. (Because nodes are numerous and small, while the
// others are few and large; so it is likely that many of the
// nodes will be subsumed by other things.)
dlog.Infof(ctx, "3/5: Processing %d nodes...", numNodes)
for _, devID := range devIDs {
devResults := scanResults[devID]
// Sort them so that progress numbers are predictable.
for _, laddr := range maps.SortedKeys(devResults.FoundNodes) {
for _, paddr := range devResults.FoundNodes[laddr] {
if err := fs.LV.AddMapping(btrfsvol.Mapping{
LAddr: laddr,
PAddr: btrfsvol.QualifiedPhysicalAddr{
Dev: devID,
Addr: paddr,
},
Size: nodeSize,
SizeLocked: false,
}); err != nil {
dlog.Errorf(ctx, "... error: adding node ident: %v", err)
}
}
}
}
dlog.Info(ctx, "... done processing nodes")
// Use block groups to add missing flags (and as a hint to
// combine node entries).
dlog.Infof(ctx, "4/5: Processing %d block groups...", numBlockGroups)
// First dedup them, because they change for allocations and
// CoW means that they'll bounce around a lot, so you likely
// have oodles of duplicates?
bgsOrdered, err := DedupBlockGroups(scanResults)
if err != nil {
return err
}
for _, bg := range bgsOrdered {
otherLAddr, otherPAddr := fs.LV.ResolveAny(bg.LAddr, bg.Size)
if otherLAddr < 0 || otherPAddr.Addr < 0 {
dlog.Errorf(ctx, "... error: could not pair blockgroup laddr=%v (size=%v flags=%v) with a mapping",
bg.LAddr, bg.Size, bg.Flags)
continue
}
offsetWithinChunk := otherLAddr.Sub(bg.LAddr)
mapping := btrfsvol.Mapping{
LAddr: bg.LAddr,
PAddr: otherPAddr.Add(-offsetWithinChunk),
Size: bg.Size,
SizeLocked: true,
Flags: containers.Optional[btrfsvol.BlockGroupFlags]{
OK: true,
Val: bg.Flags,
},
}
if err := fs.LV.AddMapping(mapping); err != nil {
dlog.Errorf(ctx, "... error: adding flags from blockgroup: %v", err)
}
}
dlog.Info(ctx, "... done processing block groups")
dlog.Infof(ctx, "5/5: Processing sums: TODO")
return nil
}
|
