1 /*
2 * This file and its contents are supplied under the terms of the
3 * Common Development and Distribution License ("CDDL"), version 1.0.
4 * You may only use this file in accordance with the terms of version
5 * 1.0 of the CDDL.
6 *
7 * A full copy of the text of the CDDL should have accompanied this
8 * source. A copy of the CDDL is also available via the Internet at
9 * http://www.illumos.org/license/CDDL.
10 */
11
12 /*
13 * Copyright (c) 2018, Joyent, Inc.
14 */
15
16 /*
17 * This module parses the private file format used for describing
18 * platform-specific USB overrides.
19 *
20 * FILE FORMAT
21 * -----------
22 *
23 * A USB topology file contains a series of lines which are separated by new
24 * lines. Leading and trailing whitespace on a line are ignored and empty lines
25 * are ignored as well. The '#' character is used as a comment character. There
26 * are a series of keywords that are supported which are used to indicate
27 * different control aspects. These keywords are all treated in a
28 * case-insensitive fashion. There are both top-level keywords and keywords that
29 * are only accepted within the context of a scope.
30 *
31 * Top-level keywords
32 * ------------------
33 *
34 * The following keywords are accepted, but must not be found inside a nested
35 * scope:
36 *
37 * 'disable-acpi' Disables the use of ACPI for this platform. This
38 * includes getting information about the port's
39 * type and visibility. This implies
40 * 'disable-acpi-match'.
41 *
42 * 'disable-acpi-match' Disables the act of trying to match ports based
43 * on ACPI.
44 *
45 *
46 * 'enable-acpi-match' Explicitly enables ACPI port matching on the
47 * platform based on ACPI.
48 *
49 * 'enable-metadata-match' Enables port matching based on metadata. This is
50 * most commonly used on platforms that have ehci
51 * and xhci controllers that share ports.
52 *
53 * 'port' Begins a port stanza that describes a single
54 * physical port. This stanza will continue until
55 * the 'end-port' keyword is encountered.
56 *
57 * Port Keywords
58 * -------------
59 *
60 * Some port keywords take arguments and others do not. When an argument exists,
61 * will occur on the subsequent line. Ports have a series of directives that
62 * describe metadata as well as directives that describe how to determine the
63 * port.
64 *
65 * 'label' Indicates that the next line contains the
66 * human-readable label for the port.
67 *
68 * 'chassis' Indicates that this port is part of the chassis
69 * and should not be enumerated elsewhere.
70 *
71 * 'external' Indicates that this port is externally visible.
72 *
73 * 'internal' Indicates that this port is internal to the
74 * chassis and cannot be accessed without opening
75 * the chassis.
76 *
77 * 'port-type' Indicates that the next line contains a number
78 * which corresponds to the type of the port. The
79 * port numbers are based on the ACPI table and
80 * may be in either base 10 or hexadecimal.
81 *
82 * 'acpi-path' Indicates that the next line contains an ACPI
83 * based name that matches the port.
84 *
85 * 'end-port' Closes the port-clause.
86 */
87
88 #include <libnvpair.h>
89 #include <sys/types.h>
90 #include <sys/stat.h>
91 #include <fcntl.h>
92 #include <fm/topo_list.h>
93 #include <fm/topo_mod.h>
94 #include <stdio.h>
95 #include <string.h>
96 #include <strings.h>
97 #include <libnvpair.h>
98 #include <sys/debug.h>
99 #include <ctype.h>
100 #include <unistd.h>
101
102 #include "topo_usb.h"
103 #include "topo_usb_int.h"
104
105 /*
106 * Maximum number of characters we expect to encounter in a line.
107 */
108 #define TOPO_USB_META_LINE_MAX 1000
109
110 /*
111 * This constant is the default set of flags that we'd like to apply when there
112 * is no configuration file present to determine the desired behavior. If one is
113 * present, we always defer to what it asks for.
114 *
115 * It's a difficult decision to enable ACPI by default or not. Unfortunately,
116 * we've encountered some systems where the ACPI information is wrong. However,
117 * we've encountered a larger number where it is correct. When it's correct,
118 * this greatly simplifies some of the work that we have to do. Our default
119 * disposition at the moment is to opt to decide its correct as that ends up
120 * giving us much better information.
121 */
122 #define USB_TOPO_META_DEFAULT_FLAGS TOPO_USB_M_ACPI_MATCH
123
124 typedef enum {
125 TOPO_USB_P_START,
126 TOPO_USB_P_PORT,
127 TOPO_USB_P_LABEL,
128 TOPO_USB_P_PORT_TYPE,
129 TOPO_USB_P_ACPI_PATH
130 } topo_usb_parse_state_t;
131
132 typedef struct topo_usb_parse {
133 topo_usb_parse_state_t tp_state;
134 topo_list_t *tp_ports;
135 topo_usb_meta_port_t *tp_cport;
136 topo_usb_meta_flags_t tp_flags;
137 } topo_usb_parse_t;
138
139 /*
140 * Read the next line in the file with content. Trim trailing and leading
141 * whitespace and trim comments out. If this results in an empty line, read the
142 * next. Returns zero if we hit EOF. Otherwise, returns one if data, or negative
143 * one if an error occurred.
144 */
145 static int
topo_usb_getline(topo_mod_t * mod,char * buf,size_t len,FILE * f,char ** first)146 topo_usb_getline(topo_mod_t *mod, char *buf, size_t len, FILE *f, char **first)
147 {
148 while (fgets(buf, len, f) != NULL) {
149 char *c;
150 size_t i;
151
152 if ((c = strrchr(buf, '\n')) == NULL) {
153 topo_mod_dprintf(mod, "failed to find new line in "
154 "metadata file");
155 return (-1);
156 }
157
158 while (isspace(*c) != 0 && c >= buf) {
159 *c = '\0';
160 c--;
161 continue;
162 }
163
164 if ((c = strchr(buf, '#')) != 0) {
165 *c = '\0';
166 }
167
168 for (i = 0; buf[i] != '\0'; i++) {
169 if (isspace(buf[i]) == 0)
170 break;
171 }
172
173 if (buf[i] == '\0')
174 continue;
175 *first = &buf[i];
176 return (1);
177 }
178
179 return (0);
180 }
181
182 static boolean_t
topo_usb_parse_start(topo_mod_t * mod,topo_usb_parse_t * parse,const char * line)183 topo_usb_parse_start(topo_mod_t *mod, topo_usb_parse_t *parse, const char *line)
184 {
185 topo_usb_meta_port_t *port;
186
187 VERIFY3S(parse->tp_state, ==, TOPO_USB_P_START);
188 VERIFY3P(parse->tp_cport, ==, NULL);
189
190 if (strcasecmp(line, "disable-acpi") == 0) {
191 parse->tp_flags |= TOPO_USB_M_NO_ACPI;
192 parse->tp_flags &= ~TOPO_USB_M_ACPI_MATCH;
193 return (B_TRUE);
194 } else if (strcasecmp(line, "disable-acpi-match") == 0) {
195 parse->tp_flags &= ~TOPO_USB_M_ACPI_MATCH;
196 return (B_TRUE);
197 } else if (strcasecmp(line, "enable-acpi-match") == 0) {
198 parse->tp_flags |= TOPO_USB_M_ACPI_MATCH;
199 return (B_TRUE);
200 } else if (strcasecmp(line, "enable-metadata-match") == 0) {
201 parse->tp_flags |= TOPO_USB_M_METADATA_MATCH;
202 return (B_TRUE);
203 } else if (strcasecmp(line, "port") != 0) {
204 topo_mod_dprintf(mod, "expected 'port', encountered %s",
205 line);
206 return (B_FALSE);
207 }
208
209 if ((port = topo_mod_zalloc(mod, sizeof (topo_usb_meta_port_t))) ==
210 NULL) {
211 topo_mod_dprintf(mod, "failed to allocate metadata port");
212 return (B_FALSE);
213 }
214 port->tmp_port_type = 0xff;
215
216 parse->tp_cport = port;
217 parse->tp_state = TOPO_USB_P_PORT;
218 return (B_TRUE);
219 }
220
221 static boolean_t
topo_usb_parse_port(topo_mod_t * mod,topo_usb_parse_t * parse,const char * line)222 topo_usb_parse_port(topo_mod_t *mod, topo_usb_parse_t *parse, const char *line)
223 {
224 VERIFY3S(parse->tp_state, ==, TOPO_USB_P_PORT);
225 VERIFY3P(parse->tp_cport, !=, NULL);
226
227 if (strcasecmp(line, "label") == 0) {
228 parse->tp_state = TOPO_USB_P_LABEL;
229 } else if (strcasecmp(line, "chassis") == 0) {
230 parse->tp_cport->tmp_flags |= TOPO_USB_F_CHASSIS;
231 } else if (strcasecmp(line, "external") == 0) {
232 parse->tp_cport->tmp_flags |= TOPO_USB_F_EXTERNAL;
233 } else if (strcasecmp(line, "internal") == 0) {
234 parse->tp_cport->tmp_flags |= TOPO_USB_F_INTERNAL;
235 } else if (strcasecmp(line, "port-type") == 0) {
236 parse->tp_state = TOPO_USB_P_PORT_TYPE;
237 } else if (strcasecmp(line, "acpi-path") == 0) {
238 parse->tp_state = TOPO_USB_P_ACPI_PATH;
239 } else if (strcasecmp(line, "end-port") == 0) {
240 topo_list_append(parse->tp_ports, parse->tp_cport);
241 parse->tp_cport = NULL;
242 parse->tp_state = TOPO_USB_P_START;
243 } else {
244 topo_mod_dprintf(mod, "illegal directive in port block: %s",
245 line);
246 return (B_FALSE);
247 }
248
249 return (B_TRUE);
250 }
251
252 static boolean_t
topo_usb_parse_label(topo_mod_t * mod,topo_usb_parse_t * parse,const char * line)253 topo_usb_parse_label(topo_mod_t *mod, topo_usb_parse_t *parse, const char *line)
254 {
255 size_t i, len;
256
257 VERIFY3S(parse->tp_state, ==, TOPO_USB_P_LABEL);
258
259 len = strlen(line);
260 for (i = 0; i < len; i++) {
261 if (isascii(line[i]) == 0 || isprint(line[i]) == 0) {
262 topo_mod_dprintf(mod, "label character %zu is "
263 "invalid: 0x%x", i, line[i]);
264 return (B_FALSE);
265 }
266 }
267
268 if (parse->tp_cport->tmp_label != NULL) {
269 topo_mod_strfree(mod, parse->tp_cport->tmp_label);
270 }
271
272 if ((parse->tp_cport->tmp_label = topo_mod_strdup(mod, line)) == NULL) {
273 topo_mod_dprintf(mod, "failed to duplicate label for port");
274 return (B_FALSE);
275 }
276
277 parse->tp_state = TOPO_USB_P_PORT;
278
279 return (B_TRUE);
280 }
281
282 static boolean_t
topo_usb_parse_port_type(topo_mod_t * mod,topo_usb_parse_t * parse,const char * line)283 topo_usb_parse_port_type(topo_mod_t *mod, topo_usb_parse_t *parse,
284 const char *line)
285 {
286 unsigned long val;
287 char *eptr;
288
289 VERIFY3S(parse->tp_state, ==, TOPO_USB_P_PORT_TYPE);
290
291 errno = 0;
292 val = strtoul(line, &eptr, 0);
293 if (errno != 0 || *eptr != '\0' || val >= UINT_MAX) {
294 topo_mod_dprintf(mod, "encountered bad value for port-type "
295 "line: %s", line);
296 return (B_FALSE);
297 }
298
299 parse->tp_cport->tmp_port_type = (uint_t)val;
300
301 parse->tp_state = TOPO_USB_P_PORT;
302 return (B_TRUE);
303 }
304
305 static boolean_t
topo_usb_parse_path(topo_mod_t * mod,topo_usb_parse_t * parse,topo_usb_path_type_t ptype,const char * line)306 topo_usb_parse_path(topo_mod_t *mod, topo_usb_parse_t *parse,
307 topo_usb_path_type_t ptype, const char *line)
308 {
309 char *fspath;
310 topo_usb_meta_port_path_t *path;
311
312 VERIFY(parse->tp_state == TOPO_USB_P_ACPI_PATH);
313 VERIFY3P(parse->tp_cport, !=, NULL);
314
315 if ((fspath = topo_mod_strdup(mod, line)) == NULL) {
316 topo_mod_dprintf(mod, "failed to duplicate path");
317 return (B_FALSE);
318 }
319
320 if ((path = topo_mod_zalloc(mod, sizeof (topo_usb_meta_port_path_t))) ==
321 NULL) {
322 topo_mod_dprintf(mod, "failed to allocate meta port path "
323 "structure");
324 topo_mod_strfree(mod, fspath);
325 return (B_FALSE);
326 }
327
328 path->tmpp_type = ptype;
329 path->tmpp_path = fspath;
330
331 topo_list_append(&parse->tp_cport->tmp_paths, path);
332
333 parse->tp_state = TOPO_USB_P_PORT;
334 return (B_TRUE);
335 }
336
337
338 void
topo_usb_free_metadata(topo_mod_t * mod,topo_list_t * metadata)339 topo_usb_free_metadata(topo_mod_t *mod, topo_list_t *metadata)
340 {
341 topo_usb_meta_port_t *mp;
342
343 while ((mp = topo_list_next(metadata)) != NULL) {
344 topo_usb_meta_port_path_t *path;
345
346 while ((path = topo_list_next((&mp->tmp_paths))) != NULL) {
347 topo_list_delete(&mp->tmp_paths, path);
348 topo_mod_strfree(mod, path->tmpp_path);
349 topo_mod_free(mod, path,
350 sizeof (topo_usb_meta_port_path_t));
351 }
352
353 topo_list_delete(metadata, mp);
354 topo_mod_strfree(mod, mp->tmp_label);
355 topo_mod_free(mod, mp, sizeof (topo_usb_meta_port_t));
356 }
357 }
358
359 int
topo_usb_load_metadata(topo_mod_t * mod,tnode_t * pnode,topo_list_t * list,topo_usb_meta_flags_t * flagsp)360 topo_usb_load_metadata(topo_mod_t *mod, tnode_t *pnode, topo_list_t *list,
361 topo_usb_meta_flags_t *flagsp)
362 {
363 int fd;
364 FILE *f = NULL;
365 char buf[TOPO_USB_META_LINE_MAX], *first, *prod;
366 int ret;
367 topo_usb_parse_t parse;
368 char pbuf[PATH_MAX];
369
370 *flagsp = USB_TOPO_META_DEFAULT_FLAGS;
371
372 /*
373 * If no product string, just leave it as is and don't attempt to get
374 * metadata.
375 */
376 if ((topo_prop_get_string(pnode, FM_FMRI_AUTHORITY,
377 FM_FMRI_AUTH_PRODUCT, &prod, &ret)) != 0) {
378 topo_mod_dprintf(mod, "skipping metadata load: failed to get "
379 "auth");
380 return (0);
381 }
382
383 if (snprintf(pbuf, sizeof (pbuf), "maps/%s-usb.usbtopo", prod) >=
384 sizeof (pbuf)) {
385 topo_mod_dprintf(mod, "skipping metadata load: product name "
386 "too long");
387 topo_mod_strfree(mod, prod);
388 return (0);
389 }
390 topo_mod_strfree(mod, prod);
391
392 if ((fd = topo_mod_file_search(mod, pbuf, O_RDONLY)) < 0) {
393 topo_mod_dprintf(mod, "skipping metadata load: couldn't find "
394 "%s", pbuf);
395 return (0);
396 }
397
398
399 if ((f = fdopen(fd, "r")) == NULL) {
400 topo_mod_dprintf(mod, "failed to fdopen metadata file %s: %s",
401 pbuf, strerror(errno));
402 VERIFY0(close(fd));
403 ret = topo_mod_seterrno(mod, EMOD_UKNOWN_ENUM);
404 goto err;
405 }
406
407 bzero(&parse, sizeof (parse));
408 parse.tp_ports = list;
409 parse.tp_state = TOPO_USB_P_START;
410
411 while ((ret = topo_usb_getline(mod, buf, sizeof (buf), f, &first)) !=
412 0) {
413 if (ret == -1) {
414 ret = topo_mod_seterrno(mod, EMOD_UKNOWN_ENUM);
415 goto err;
416 }
417
418 switch (parse.tp_state) {
419 case TOPO_USB_P_START:
420 if (!topo_usb_parse_start(mod, &parse, first)) {
421 ret = topo_mod_seterrno(mod, EMOD_UKNOWN_ENUM);
422 goto err;
423 }
424 break;
425 case TOPO_USB_P_PORT:
426 if (!topo_usb_parse_port(mod, &parse, first)) {
427 ret = topo_mod_seterrno(mod, EMOD_UKNOWN_ENUM);
428 goto err;
429 }
430 break;
431 case TOPO_USB_P_LABEL:
432 if (!topo_usb_parse_label(mod, &parse, first)) {
433 ret = topo_mod_seterrno(mod, EMOD_UKNOWN_ENUM);
434 goto err;
435 }
436 break;
437 case TOPO_USB_P_PORT_TYPE:
438 if (!topo_usb_parse_port_type(mod, &parse, first)) {
439 ret = topo_mod_seterrno(mod, EMOD_UKNOWN_ENUM);
440 goto err;
441 }
442 break;
443
444 case TOPO_USB_P_ACPI_PATH:
445 if (!topo_usb_parse_path(mod, &parse, TOPO_USB_T_ACPI,
446 first)) {
447 ret = topo_mod_seterrno(mod, EMOD_UKNOWN_ENUM);
448 goto err;
449 }
450 break;
451 }
452 }
453
454 if (parse.tp_state != TOPO_USB_P_START) {
455 topo_mod_dprintf(mod, "metadata file didn't end in correct "
456 "state, failing");
457 ret = topo_mod_seterrno(mod, EMOD_UKNOWN_ENUM);
458 goto err;
459 }
460
461 topo_mod_dprintf(mod, "successfully loaded metadata %s", pbuf);
462 VERIFY0(fclose(f));
463 *flagsp = parse.tp_flags;
464 return (0);
465
466 err:
467 if (f != NULL)
468 VERIFY0(fclose(f));
469 topo_usb_free_metadata(mod, list);
470 return (ret);
471 }
472