/
unix_common.go
234 lines (194 loc) · 6.81 KB
/
unix_common.go
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
package device
import (
"fmt"
"os"
"path/filepath"
"strings"
deviceConfig "github.com/lxc/lxd/lxd/device/config"
"github.com/lxc/lxd/lxd/fsmonitor/drivers"
"github.com/lxc/lxd/lxd/instance"
"github.com/lxc/lxd/lxd/instance/instancetype"
"github.com/lxc/lxd/lxd/storage/filesystem"
"github.com/lxc/lxd/shared"
"github.com/lxc/lxd/shared/validate"
)
// unixIsOurDeviceType checks that device file type matches what we are expecting in the config.
func unixIsOurDeviceType(config deviceConfig.Device, dType string) bool {
if config["type"] == "unix-char" && dType == "c" {
return true
}
if config["type"] == "unix-block" && dType == "b" {
return true
}
return false
}
type unixCommon struct {
deviceCommon
}
// isRequired indicates whether the device config requires this device to start OK.
func (d *unixCommon) isRequired() bool {
// Defaults to required.
return shared.IsTrueOrEmpty(d.config["required"])
}
// validateConfig checks the supplied config for correctness.
func (d *unixCommon) validateConfig(instConf instance.ConfigReader) error {
if !instanceSupported(instConf.Type(), instancetype.Container) {
return ErrUnsupportedDevType
}
rules := map[string]func(string) error{
"source": func(value string) error {
if value == "" {
return nil
}
if strings.HasPrefix(value, d.state.DevMonitor.PrefixPath()) {
return nil
}
return &drivers.ErrInvalidPath{PrefixPath: d.state.DevMonitor.PrefixPath()}
},
"path": validate.IsAny,
"major": unixValidDeviceNum,
"minor": unixValidDeviceNum,
"uid": unixValidUserID,
"gid": unixValidUserID,
"mode": unixValidOctalFileMode,
"required": validate.Optional(validate.IsBool),
}
err := d.config.Validate(rules)
if err != nil {
return err
}
if d.config["source"] == "" && d.config["path"] == "" {
return fmt.Errorf("Unix device entry is missing the required \"source\" or \"path\" property")
}
return nil
}
// Register is run after the device is started or when LXD starts.
func (d *unixCommon) Register() error {
// Don't register for hot plug events if the device is required.
if d.isRequired() {
return nil
}
// Extract variables needed to run the event hook so that the reference to this device
// struct is not needed to be kept in memory.
devicesPath := d.inst.DevicesPath()
devConfig := d.config
deviceName := d.name
state := d.state
// Handler for when a Unix event occurs.
f := func(e UnixEvent) (*deviceConfig.RunConfig, error) {
// Check if the event is for a device file that this device wants.
if unixDeviceSourcePath(devConfig) != e.Path {
return nil, nil
}
// Derive the host side path for the instance device file.
ourPrefix := deviceJoinPath("unix", deviceName)
relativeDestPath := strings.TrimPrefix(unixDeviceDestPath(devConfig), "/")
devName := filesystem.PathNameEncode(deviceJoinPath(ourPrefix, relativeDestPath))
devPath := filepath.Join(devicesPath, devName)
runConf := deviceConfig.RunConfig{}
if e.Action == "add" {
// Skip if host side instance device file already exists.
if shared.PathExists(devPath) {
return nil, nil
}
// Get the file type and ensure it matches what the user was expecting.
dType, _, _, err := unixDeviceAttributes(e.Path)
if err != nil {
if os.IsNotExist(err) {
// Skip if host side source device doesn't exist.
// This could be an event for the parent directory being added.
return nil, nil
}
return nil, fmt.Errorf("Failed getting device attributes: %w", err)
}
if !unixIsOurDeviceType(d.config, dType) {
return nil, fmt.Errorf("Path specified is not a %s device", d.config["type"])
}
err = unixDeviceSetup(state, devicesPath, "unix", deviceName, devConfig, true, &runConf)
if err != nil {
return nil, err
}
} else if e.Action == "remove" {
// Skip if host side instance device file doesn't exist.
if !shared.PathExists(devPath) {
return nil, nil
}
err := unixDeviceRemove(devicesPath, "unix", deviceName, relativeDestPath, &runConf)
if err != nil {
return nil, err
}
// Add a post hook function to remove the specific USB device file after unmount.
runConf.PostHooks = []func() error{func() error {
err := unixDeviceDeleteFiles(state, devicesPath, "unix", deviceName, relativeDestPath)
if err != nil {
return fmt.Errorf("Failed to delete files for device '%s': %w", deviceName, err)
}
return nil
}}
}
return &runConf, nil
}
// Register the handler function against the device's source path.
subPath := unixDeviceSourcePath(devConfig)
err := unixRegisterHandler(d.state, d.inst, d.name, subPath, f)
if err != nil {
return err
}
return nil
}
// Start is run when the device is added to the container.
func (d *unixCommon) Start() (*deviceConfig.RunConfig, error) {
runConf := deviceConfig.RunConfig{}
runConf.PostHooks = []func() error{d.Register}
srcPath := unixDeviceSourcePath(d.config)
// If device file already exists on system, proceed to add it whether its required or not.
dType, _, _, err := unixDeviceAttributes(srcPath)
if err == nil {
// Ensure device type matches what the device config is expecting.
if !unixIsOurDeviceType(d.config, dType) {
return nil, fmt.Errorf("Path specified is not a %s device", d.config["type"])
}
err = unixDeviceSetup(d.state, d.inst.DevicesPath(), "unix", d.name, d.config, true, &runConf)
if err != nil {
return nil, err
}
} else {
// If the device file doesn't exist on the system, but major & minor numbers have
// been provided in the config then we can go ahead and create the device anyway.
if d.config["major"] != "" && d.config["minor"] != "" {
err := unixDeviceSetup(d.state, d.inst.DevicesPath(), "unix", d.name, d.config, true, &runConf)
if err != nil {
return nil, err
}
} else if d.isRequired() {
// If the file is missing and the device is required then we cannot proceed.
return nil, fmt.Errorf("The required device path doesn't exist and the major and minor settings are not specified")
}
}
return &runConf, nil
}
// Stop is run when the device is removed from the instance.
func (d *unixCommon) Stop() (*deviceConfig.RunConfig, error) {
// Unregister any Unix event handlers for this device.
err := unixUnregisterHandler(d.state, d.inst, d.name)
if err != nil {
return nil, err
}
runConf := deviceConfig.RunConfig{
PostHooks: []func() error{d.postStop},
}
err = unixDeviceRemove(d.inst.DevicesPath(), "unix", d.name, "", &runConf)
if err != nil {
return nil, err
}
return &runConf, nil
}
// postStop is run after the device is removed from the instance.
func (d *unixCommon) postStop() error {
// Remove host files for this device.
err := unixDeviceDeleteFiles(d.state, d.inst.DevicesPath(), "unix", d.name, "")
if err != nil {
return fmt.Errorf("Failed to delete files for device '%s': %w", d.name, err)
}
return nil
}