-
Notifications
You must be signed in to change notification settings - Fork 0
/
usb.go
247 lines (201 loc) · 5.91 KB
/
usb.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
235
236
237
238
239
240
241
242
243
244
245
246
247
package device
import (
"fmt"
"io/ioutil"
"os"
"path"
"strings"
deviceConfig "github.com/lxc/lxd/lxd/device/config"
"github.com/lxc/lxd/lxd/instance"
"github.com/lxc/lxd/lxd/instance/instancetype"
"github.com/lxc/lxd/shared"
)
// usbDevPath is the path where USB devices can be enumerated.
const usbDevPath = "/sys/bus/usb/devices"
// usbIsOurDevice indicates whether the USB device event qualifies as part of our device.
// This function is not defined against the usb struct type so that it can be used in event
// callbacks without needing to keep a reference to the usb device struct.
func usbIsOurDevice(config deviceConfig.Device, usb *USBEvent) bool {
// Check if event matches criteria for this device, if not return.
if (config["vendorid"] != "" && config["vendorid"] != usb.Vendor) || (config["productid"] != "" && config["productid"] != usb.Product) {
return false
}
return true
}
type usb struct {
deviceCommon
}
// isRequired indicates whether the device config requires this device to start OK.
func (d *usb) isRequired() bool {
// Defaults to not required.
if shared.IsTrue(d.config["required"]) {
return true
}
return false
}
// validateConfig checks the supplied config for correctness.
func (d *usb) validateConfig(instConf instance.ConfigReader) error {
if !instanceSupported(instConf.Type(), instancetype.Container) {
return ErrUnsupportedDevType
}
rules := map[string]func(string) error{
"vendorid": shared.IsDeviceID,
"productid": shared.IsDeviceID,
"uid": unixValidUserID,
"gid": unixValidUserID,
"mode": unixValidOctalFileMode,
"required": shared.IsBool,
}
err := d.config.Validate(rules)
if err != nil {
return err
}
return nil
}
// Register is run after the device is started or when LXD starts.
func (d *usb) Register() error {
// 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 USB event occurs.
f := func(e USBEvent) (*deviceConfig.RunConfig, error) {
if !usbIsOurDevice(devConfig, &e) {
return nil, nil
}
runConf := deviceConfig.RunConfig{}
if e.Action == "add" {
err := unixDeviceSetupCharNum(state, devicesPath, "unix", deviceName, devConfig, e.Major, e.Minor, e.Path, false, &runConf)
if err != nil {
return nil, err
}
} else if e.Action == "remove" {
relativeTargetPath := strings.TrimPrefix(e.Path, "/")
err := unixDeviceRemove(devicesPath, "unix", deviceName, relativeTargetPath, &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, relativeTargetPath)
if err != nil {
return fmt.Errorf("Failed to delete files for device '%s': %v", deviceName, err)
}
return nil
}}
}
runConf.Uevents = append(runConf.Uevents, e.UeventParts)
return &runConf, nil
}
usbRegisterHandler(d.inst, d.name, f)
return nil
}
// Start is run when the device is added to the instance.
func (d *usb) Start() (*deviceConfig.RunConfig, error) {
usbs, err := d.loadUsb()
if err != nil {
return nil, err
}
runConf := deviceConfig.RunConfig{}
runConf.PostHooks = []func() error{d.Register}
for _, usb := range usbs {
if !usbIsOurDevice(d.config, &usb) {
continue
}
err := unixDeviceSetupCharNum(d.state, d.inst.DevicesPath(), "unix", d.name, d.config, usb.Major, usb.Minor, usb.Path, false, &runConf)
if err != nil {
return nil, err
}
}
if d.isRequired() && len(runConf.Mounts) <= 0 {
return nil, fmt.Errorf("Required USB device not found")
}
return &runConf, nil
}
// Stop is run when the device is removed from the instance.
func (d *usb) Stop() (*deviceConfig.RunConfig, error) {
// Unregister any USB event handlers for this device.
usbUnregisterHandler(d.inst, d.name)
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 *usb) 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': %v", d.name, err)
}
return nil
}
// loadUsb scans the host machine for USB devices.
func (d *usb) loadUsb() ([]USBEvent, error) {
result := []USBEvent{}
ents, err := ioutil.ReadDir(usbDevPath)
if err != nil {
/* if there are no USB devices, let's render an empty list,
* i.e. no usb devices */
if os.IsNotExist(err) {
return result, nil
}
return nil, err
}
for _, ent := range ents {
values, err := d.loadRawValues(path.Join(usbDevPath, ent.Name()))
if err != nil {
if os.IsNotExist(err) {
continue
}
return []USBEvent{}, err
}
parts := strings.Split(values["dev"], ":")
if len(parts) != 2 {
return []USBEvent{}, fmt.Errorf("invalid device value %s", values["dev"])
}
usb, err := USBNewEvent(
"add",
values["idVendor"],
values["idProduct"],
parts[0],
parts[1],
values["busnum"],
values["devnum"],
values["devname"],
[]string{},
0,
)
if err != nil {
if os.IsNotExist(err) {
continue
}
return nil, err
}
result = append(result, usb)
}
return result, nil
}
func (d *usb) loadRawValues(p string) (map[string]string, error) {
values := map[string]string{
"idVendor": "",
"idProduct": "",
"dev": "",
"busnum": "",
"devnum": "",
}
for k := range values {
v, err := ioutil.ReadFile(path.Join(p, k))
if err != nil {
return nil, err
}
values[k] = strings.TrimSpace(string(v))
}
return values, nil
}