1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
24 * Copyright (c) 2015, Joyent, Inc. All rights reserved.
25 * Copyright 2022 Garrett D'Amore <garrett@damore.org>
26 * Copyright 2023 Oxide Computer Company
27 */
28
29 #include <regex.h>
30 #include <devfsadm.h>
31 #include <stdio.h>
32 #include <strings.h>
33 #include <stdlib.h>
34 #include <limits.h>
35 #include <sys/zone.h>
36 #include <sys/zcons.h>
37 #include <sys/cpuid_drv.h>
38
39 static int display(di_minor_t minor, di_node_t node);
40 static int parallel(di_minor_t minor, di_node_t node);
41 static int node_slash_minor(di_minor_t minor, di_node_t node);
42 static int driver_minor(di_minor_t minor, di_node_t node);
43 static int node_name(di_minor_t minor, di_node_t node);
44 static int minor_name(di_minor_t minor, di_node_t node);
45 static int wifi_minor_name(di_minor_t minor, di_node_t node);
46 static int conskbd(di_minor_t minor, di_node_t node);
47 static int consms(di_minor_t minor, di_node_t node);
48 static int power_button(di_minor_t minor, di_node_t node);
49 static int fc_port(di_minor_t minor, di_node_t node);
50 static int printer_create(di_minor_t minor, di_node_t node);
51 static int se_hdlc_create(di_minor_t minor, di_node_t node);
52 static int ppm(di_minor_t minor, di_node_t node);
53 static int gpio(di_minor_t minor, di_node_t node);
54 static int av_create(di_minor_t minor, di_node_t node);
55 static int tsalarm_create(di_minor_t minor, di_node_t node);
56 static int ntwdt_create(di_minor_t minor, di_node_t node);
57 static int zcons_create(di_minor_t minor, di_node_t node);
58 static int cpuid(di_minor_t minor, di_node_t node);
59 static int glvc(di_minor_t minor, di_node_t node);
60 static int ses_callback(di_minor_t minor, di_node_t node);
61 static int kmdrv_create(di_minor_t minor, di_node_t node);
62 static int vio9p_create(di_minor_t minor, di_node_t node);
63 static int eeprom_create(di_minor_t minor, di_node_t node);
64
65 static devfsadm_create_t misc_cbt[] = {
66 { "pseudo", "ddi_pseudo", "(^sad$)",
67 TYPE_EXACT | DRV_RE, ILEVEL_0, node_slash_minor
68 },
69 { "pseudo", "ddi_pseudo", "zsh",
70 TYPE_EXACT | DRV_EXACT, ILEVEL_0, driver_minor
71 },
72 { "network", "ddi_network", NULL,
73 TYPE_EXACT, ILEVEL_0, minor_name
74 },
75 { "wifi", "ddi_network:wifi", NULL,
76 TYPE_EXACT, ILEVEL_0, wifi_minor_name
77 },
78 { "display", "ddi_display", NULL,
79 TYPE_EXACT, ILEVEL_0, display
80 },
81 { "parallel", "ddi_parallel", NULL,
82 TYPE_EXACT, ILEVEL_0, parallel
83 },
84 { "enclosure", DDI_NT_SCSI_ENCLOSURE, NULL,
85 TYPE_EXACT, ILEVEL_0, ses_callback
86 },
87 { "pseudo", "ddi_pseudo", "(^pm$)",
88 TYPE_EXACT | DRV_RE, ILEVEL_0, node_name
89 },
90 { "pseudo", "ddi_pseudo", "conskbd",
91 TYPE_EXACT | DRV_EXACT, ILEVEL_0, conskbd
92 },
93 { "pseudo", "ddi_pseudo", "consms",
94 TYPE_EXACT | DRV_EXACT, ILEVEL_0, consms
95 },
96 { "pseudo", "ddi_pseudo", "eventfd",
97 TYPE_EXACT | DRV_EXACT, ILEVEL_0, minor_name
98 },
99 { "pseudo", "ddi_pseudo", "signalfd",
100 TYPE_EXACT | DRV_EXACT, ILEVEL_0, minor_name
101 },
102 { "pseudo", "ddi_pseudo", "rsm",
103 TYPE_EXACT | DRV_EXACT, ILEVEL_0, minor_name
104 },
105 { "pseudo", "ddi_pseudo",
106 "(^lockstat$)|(^SUNW,rtvc$)|(^vol$)|(^log$)|(^sy$)|"
107 "(^ksyms$)|(^clone$)|(^tl$)|(^kstat$)|(^mdesc$)|(^eeprom$)|"
108 "(^ptsl$)|(^mm$)|(^wc$)|(^dump$)|(^cn$)|(^svvslo$)|(^ptm$)|"
109 "(^ptc$)|(^openeepr$)|(^poll$)|(^sysmsg$)|(^random$)|(^trapstat$)|"
110 "(^cryptoadm$)|(^crypto$)|(^pool$)|(^poolctl$)|(^bl$)|(^kmdb$)|"
111 "(^sysevent$)|(^physmem$)",
112 TYPE_EXACT | DRV_RE, ILEVEL_1, minor_name
113 },
114 { "pseudo", "ddi_pseudo",
115 "(^ip$)|(^tcp$)|(^udp$)|(^icmp$)|"
116 "(^ip6$)|(^tcp6$)|(^udp6$)|(^icmp6$)|"
117 "(^rts$)|(^arp$)|(^ipsecah$)|(^ipsecesp$)|(^keysock$)|(^spdsock$)|"
118 "(^rds$)|(^sdp$)|(^ipnet$)|(^dlpistub$)|(^bpf$)",
119 TYPE_EXACT | DRV_RE, ILEVEL_1, minor_name
120 },
121 { "pseudo", "ddi_pseudo", "ipd",
122 TYPE_EXACT | DRV_EXACT, ILEVEL_0, minor_name
123 },
124 { "pseudo", "ddi_pseudo",
125 "(^ipf$)|(^ipnat$)|(^ipstate$)|(^ipauth$)|"
126 "(^ipsync$)|(^ipscan$)|(^iplookup$)",
127 TYPE_EXACT | DRV_RE, ILEVEL_0, minor_name,
128 },
129 { "pseudo", "ddi_pseudo", "dld",
130 TYPE_EXACT | DRV_EXACT, ILEVEL_0, node_name
131 },
132 { "pseudo", "ddi_pseudo",
133 "(^kdmouse$)|(^rootprop$)",
134 TYPE_EXACT | DRV_RE, ILEVEL_0, node_name
135 },
136 { "pseudo", "ddi_pseudo", "timerfd",
137 TYPE_EXACT | DRV_EXACT, ILEVEL_0, minor_name
138 },
139 { "pseudo", "ddi_pseudo", "tod",
140 TYPE_EXACT | DRV_EXACT, ILEVEL_0, node_name
141 },
142 { "pseudo", "ddi_pseudo", "envctrl(two)?",
143 TYPE_EXACT | DRV_RE, ILEVEL_1, minor_name,
144 },
145 { "pseudo", "ddi_pseudo", "fcode",
146 TYPE_EXACT | DRV_RE, ILEVEL_0, minor_name,
147 },
148 { "power_button", "ddi_power_button", NULL,
149 TYPE_EXACT, ILEVEL_0, power_button,
150 },
151 { "FC port", "ddi_ctl:devctl", "fp",
152 TYPE_EXACT | DRV_EXACT, ILEVEL_0, fc_port
153 },
154 { "printer", "ddi_printer", NULL,
155 TYPE_EXACT, ILEVEL_0, printer_create
156 },
157 { "pseudo", "ddi_pseudo", "se",
158 TYPE_EXACT | DRV_EXACT, ILEVEL_0, se_hdlc_create
159 },
160 { "ppm", "ddi_ppm", NULL,
161 TYPE_EXACT, ILEVEL_0, ppm
162 },
163 { "pseudo", "ddi_pseudo", "gpio_87317",
164 TYPE_EXACT | DRV_EXACT, ILEVEL_0, gpio
165 },
166 { "pseudo", "ddi_pseudo", "sckmdrv",
167 TYPE_EXACT | DRV_RE, ILEVEL_0, kmdrv_create,
168 },
169 { "pseudo", "ddi_pseudo", "oplkmdrv",
170 TYPE_EXACT | DRV_RE, ILEVEL_0, kmdrv_create,
171 },
172 { "av", "^ddi_av:(isoch|async)$", NULL,
173 TYPE_RE, ILEVEL_0, av_create,
174 },
175 { "pseudo", "ddi_pseudo", "tsalarm",
176 TYPE_EXACT | DRV_RE, ILEVEL_0, tsalarm_create,
177 },
178 { "pseudo", "ddi_pseudo", "ntwdt",
179 TYPE_EXACT | DRV_RE, ILEVEL_0, ntwdt_create,
180 },
181 { "pseudo", "ddi_pseudo", "daplt",
182 TYPE_EXACT | DRV_EXACT, ILEVEL_0, minor_name
183 },
184 { "pseudo", "ddi_pseudo", "zcons",
185 TYPE_EXACT | DRV_EXACT, ILEVEL_0, zcons_create,
186 },
187 { "pseudo", "ddi_pseudo", CPUID_DRIVER_NAME,
188 TYPE_EXACT | DRV_EXACT, ILEVEL_0, cpuid,
189 },
190 { "pseudo", "ddi_pseudo", "glvc",
191 TYPE_EXACT | DRV_EXACT, ILEVEL_0, glvc,
192 },
193 { "pseudo", "ddi_pseudo", "dm2s",
194 TYPE_EXACT | DRV_EXACT, ILEVEL_0, minor_name,
195 },
196 { "pseudo", "ddi_pseudo", "nsmb",
197 TYPE_EXACT | DRV_EXACT, ILEVEL_1, minor_name,
198 },
199 { "pseudo", "ddi_pseudo", "mem_cache",
200 TYPE_EXACT | DRV_RE, ILEVEL_1, minor_name,
201 },
202 { "pseudo", "ddi_pseudo", "fm",
203 TYPE_EXACT | DRV_RE, ILEVEL_1, minor_name,
204 },
205 { "pseudo", "ddi_pseudo", "smbsrv1?",
206 TYPE_EXACT | DRV_RE, ILEVEL_1, minor_name,
207 },
208 { "pseudo", "ddi_pseudo", "tpm",
209 TYPE_EXACT | DRV_EXACT, ILEVEL_0, minor_name
210 },
211 { "pseudo", "ddi_pseudo", "overlay",
212 TYPE_EXACT | DRV_EXACT, ILEVEL_0, minor_name
213 },
214 { "9p", "ddi_pseudo", "vio9p",
215 TYPE_EXACT | DRV_EXACT, ILEVEL_0, vio9p_create,
216 },
217 { "pseudo", "ddi_pseudo", "ktest",
218 TYPE_EXACT | DRV_EXACT, ILEVEL_0, minor_name
219 },
220 { "psuedo", DDI_NT_EEPROM, "eedev",
221 TYPE_EXACT | DRV_EXACT, ILEVEL_0, eeprom_create
222 }
223 };
224
225 DEVFSADM_CREATE_INIT_V0(misc_cbt);
226
227 static devfsadm_remove_t misc_remove_cbt[] = {
228 { "pseudo", "^profile$",
229 RM_PRE | RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
230 },
231 { "pseudo", "^rsm$",
232 RM_PRE | RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
233 },
234 { "printer", "^printers/[0-9]+$",
235 RM_PRE | RM_HOT | RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
236 },
237 { "av", "^av/[0-9]+/(async|isoch)$",
238 RM_PRE | RM_HOT | RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
239 },
240 { "pseudo", "^daplt$",
241 RM_PRE | RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
242 },
243 { "pseudo", "^zcons/" ZONENAME_REGEXP "/(" ZCONS_MANAGER_NAME "|"
244 ZCONS_SUBSIDIARY_NAME ")$",
245 RM_PRE | RM_HOT | RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
246 },
247 { "pseudo", "^" CPUID_SELF_NAME "$", RM_ALWAYS | RM_PRE | RM_HOT,
248 ILEVEL_0, devfsadm_rm_all
249 },
250 { "enclosure", "^es/ses[0-9]+$", RM_POST,
251 ILEVEL_0, devfsadm_rm_all
252 },
253 { "pseudo", "^pfil$",
254 RM_PRE | RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
255 },
256 { "pseudo", "^tpm$",
257 RM_PRE | RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
258 },
259 { "pseudo", "^sctp|sctp6$",
260 RM_PRE | RM_ALWAYS, ILEVEL_0, devfsadm_rm_link
261 },
262 { "9p", "^9p/[0-9]+$",
263 RM_PRE | RM_HOT | RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
264 },
265 { "pesudo", "^eeprom/.*$",
266 RM_PRE | RM_HOT | RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
267 },
268 };
269
270 /* Rules for gpio devices */
271 static devfsadm_enumerate_t gpio_rules[1] =
272 {"^gpio([0-9]+)$", 1, MATCH_ALL};
273
274 DEVFSADM_REMOVE_INIT_V0(misc_remove_cbt);
275
276 /*
277 * Handles minor node type "ddi_display".
278 *
279 * type=ddi_display fbs/\M0 fb\N0
280 */
281 static int
display(di_minor_t minor,di_node_t node)282 display(di_minor_t minor, di_node_t node)
283 {
284 char l_path[PATH_MAX + 1], contents[PATH_MAX + 1], *buf;
285 devfsadm_enumerate_t rules[1] = {"^fb([0-9]+)$", 1, MATCH_ALL};
286 char *mn = di_minor_name(minor);
287
288 /* create fbs/\M0 primary link */
289 (void) strcpy(l_path, "fbs/");
290 (void) strcat(l_path, mn);
291 (void) devfsadm_mklink(l_path, node, minor, 0);
292
293 /* create fb\N0 which links to fbs/\M0 */
294 if (devfsadm_enumerate_int(l_path, 0, &buf, rules, 1)) {
295 return (DEVFSADM_CONTINUE);
296 }
297 (void) strcpy(contents, l_path);
298 (void) strcpy(l_path, "fb");
299 (void) strcat(l_path, buf);
300 free(buf);
301 (void) devfsadm_secondary_link(l_path, contents, 0);
302 return (DEVFSADM_CONTINUE);
303 }
304
305 /*
306 * Handles minor node type "ddi_parallel".
307 * type=ddi_parallel;name=mcpp mcpp\N0
308 */
309 static int
parallel(di_minor_t minor,di_node_t node)310 parallel(di_minor_t minor, di_node_t node)
311 {
312 char path[PATH_MAX + 1], *buf;
313 devfsadm_enumerate_t rules[1] = {"mcpp([0-9]+)$", 1, MATCH_ALL};
314
315
316 if (strcmp(di_node_name(node), "mcpp") != 0) {
317 return (DEVFSADM_CONTINUE);
318 }
319
320 if (NULL == (buf = di_devfs_path(node))) {
321 return (DEVFSADM_CONTINUE);
322 }
323
324 (void) snprintf(path, sizeof (path), "%s:%s",
325 buf, di_minor_name(minor));
326
327 di_devfs_path_free(buf);
328
329 if (devfsadm_enumerate_int(path, 0, &buf, rules, 1)) {
330 return (DEVFSADM_CONTINUE);
331 }
332 (void) snprintf(path, sizeof (path), "mcpp%s", buf);
333 free(buf);
334
335 (void) devfsadm_mklink(path, node, minor, 0);
336 return (DEVFSADM_CONTINUE);
337 }
338
339 static int
ses_callback(di_minor_t minor,di_node_t node)340 ses_callback(di_minor_t minor, di_node_t node)
341 {
342 char l_path[PATH_MAX];
343 char *buf;
344 char *devfspath;
345 char p_path[PATH_MAX];
346 devfsadm_enumerate_t re[] = {"^es$/^ses([0-9]+)$", 1, MATCH_ALL};
347
348 /* find devices path -- need to free mem */
349 if (NULL == (devfspath = di_devfs_path(node))) {
350 return (DEVFSADM_CONTINUE);
351 }
352
353 (void) snprintf(p_path, sizeof (p_path), "%s:%s", devfspath,
354 di_minor_name(minor));
355
356
357 /* find next number to use; buf is an ascii number */
358 if (devfsadm_enumerate_int(p_path, 0, &buf, re, 1)) {
359 /* free memory */
360 di_devfs_path_free(devfspath);
361 return (DEVFSADM_CONTINUE);
362 }
363
364 (void) snprintf(l_path, sizeof (l_path), "es/ses%s", buf);
365
366 (void) devfsadm_mklink(l_path, node, minor, 0);
367 /* free memory */
368 free(buf);
369 di_devfs_path_free(devfspath);
370 return (DEVFSADM_CONTINUE);
371
372 }
373
374 static int
node_slash_minor(di_minor_t minor,di_node_t node)375 node_slash_minor(di_minor_t minor, di_node_t node)
376 {
377
378 char path[PATH_MAX + 1];
379
380 (void) strcpy(path, di_node_name(node));
381 (void) strcat(path, "/");
382 (void) strcat(path, di_minor_name(minor));
383 (void) devfsadm_mklink(path, node, minor, 0);
384 return (DEVFSADM_CONTINUE);
385 }
386
387 static int
driver_minor(di_minor_t minor,di_node_t node)388 driver_minor(di_minor_t minor, di_node_t node)
389 {
390 char path[PATH_MAX + 1];
391
392 (void) strcpy(path, di_driver_name(node));
393 (void) strcat(path, di_minor_name(minor));
394 (void) devfsadm_mklink(path, node, minor, 0);
395 return (DEVFSADM_CONTINUE);
396 }
397
398 /*
399 * Handles links of the form:
400 * type=ddi_pseudo;name=xyz \D
401 */
402 static int
node_name(di_minor_t minor,di_node_t node)403 node_name(di_minor_t minor, di_node_t node)
404 {
405 (void) devfsadm_mklink(di_node_name(node), node, minor, 0);
406 return (DEVFSADM_CONTINUE);
407 }
408
409 /*
410 * Handles links of the form:
411 * type=ddi_pseudo;name=xyz \M0
412 */
413 static int
minor_name(di_minor_t minor,di_node_t node)414 minor_name(di_minor_t minor, di_node_t node)
415 {
416 char *mn = di_minor_name(minor);
417
418 (void) devfsadm_mklink(mn, node, minor, 0);
419 if (strcmp(mn, "icmp") == 0) {
420 (void) devfsadm_mklink("rawip", node, minor, 0);
421 }
422 if (strcmp(mn, "icmp6") == 0) {
423 (void) devfsadm_mklink("rawip6", node, minor, 0);
424 }
425 if (strcmp(mn, "ipf") == 0) {
426 (void) devfsadm_mklink("ipl", node, minor, 0);
427 }
428 return (DEVFSADM_CONTINUE);
429 }
430
431 /*
432 * create links at /dev/wifi for wifi minor node
433 */
434 static int
wifi_minor_name(di_minor_t minor,di_node_t node)435 wifi_minor_name(di_minor_t minor, di_node_t node)
436 {
437 char buf[256];
438 char *mn = di_minor_name(minor);
439
440 (void) snprintf(buf, sizeof (buf), "%s%s", "wifi/", mn);
441 (void) devfsadm_mklink(buf, node, minor, 0);
442
443 return (DEVFSADM_CONTINUE);
444 }
445
446 static int
conskbd(di_minor_t minor,di_node_t node)447 conskbd(di_minor_t minor, di_node_t node)
448 {
449 (void) devfsadm_mklink("kbd", node, minor, 0);
450 return (DEVFSADM_CONTINUE);
451 }
452
453 static int
consms(di_minor_t minor,di_node_t node)454 consms(di_minor_t minor, di_node_t node)
455 {
456 (void) devfsadm_mklink("mouse", node, minor, 0);
457 return (DEVFSADM_CONTINUE);
458 }
459
460 static int
power_button(di_minor_t minor,di_node_t node)461 power_button(di_minor_t minor, di_node_t node)
462 {
463 (void) devfsadm_mklink("power_button", node, minor, 0);
464 return (DEVFSADM_CONTINUE);
465 }
466
467 static int
fc_port(di_minor_t minor,di_node_t node)468 fc_port(di_minor_t minor, di_node_t node)
469 {
470 devfsadm_enumerate_t rules[1] = {"fc/fp([0-9]+)$", 1, MATCH_ALL};
471 char *buf, path[PATH_MAX + 1];
472 char *ptr;
473
474 if (NULL == (ptr = di_devfs_path(node))) {
475 return (DEVFSADM_CONTINUE);
476 }
477
478 (void) strcpy(path, ptr);
479 (void) strcat(path, ":");
480 (void) strcat(path, di_minor_name(minor));
481
482 di_devfs_path_free(ptr);
483
484 if (devfsadm_enumerate_int(path, 0, &buf, rules, 1) != 0) {
485 return (DEVFSADM_CONTINUE);
486 }
487
488 (void) strcpy(path, "fc/fp");
489 (void) strcat(path, buf);
490 free(buf);
491
492 (void) devfsadm_mklink(path, node, minor, 0);
493 return (DEVFSADM_CONTINUE);
494 }
495
496 /*
497 * Handles:
498 * minor node type "ddi_printer".
499 * rules of the form: type=ddi_printer;name=bpp \M0
500 */
501 static int
printer_create(di_minor_t minor,di_node_t node)502 printer_create(di_minor_t minor, di_node_t node)
503 {
504 char *mn;
505 char path[PATH_MAX + 1], *buf;
506 devfsadm_enumerate_t rules[1] = {"^printers$/^([0-9]+)$", 1, MATCH_ALL};
507
508 mn = di_minor_name(minor);
509
510 if (strcmp(di_driver_name(node), "bpp") == 0) {
511 (void) devfsadm_mklink(mn, node, minor, 0);
512 }
513
514 if (NULL == (buf = di_devfs_path(node))) {
515 return (DEVFSADM_CONTINUE);
516 }
517
518 (void) snprintf(path, sizeof (path), "%s:%s", buf, mn);
519 di_devfs_path_free(buf);
520
521 if (devfsadm_enumerate_int(path, 0, &buf, rules, 1)) {
522 return (DEVFSADM_CONTINUE);
523 }
524
525 (void) snprintf(path, sizeof (path), "printers/%s", buf);
526 free(buf);
527
528 (void) devfsadm_mklink(path, node, minor, 0);
529
530 return (DEVFSADM_CONTINUE);
531 }
532
533 /*
534 * Handles links of the form:
535 * type=ddi_pseudo;name=se;minor2=hdlc se_hdlc\N0
536 * type=ddi_pseudo;name=serial;minor2=hdlc se_hdlc\N0
537 */
538 static int
se_hdlc_create(di_minor_t minor,di_node_t node)539 se_hdlc_create(di_minor_t minor, di_node_t node)
540 {
541 devfsadm_enumerate_t rules[1] = {"^se_hdlc([0-9]+)$", 1, MATCH_ALL};
542 char *buf, path[PATH_MAX + 1];
543 char *ptr;
544 char *mn;
545
546 mn = di_minor_name(minor);
547
548 /* minor node should be of the form: "?,hdlc" */
549 if (strcmp(mn + 1, ",hdlc") != 0) {
550 return (DEVFSADM_CONTINUE);
551 }
552
553 if (NULL == (ptr = di_devfs_path(node))) {
554 return (DEVFSADM_CONTINUE);
555 }
556
557 (void) strcpy(path, ptr);
558 (void) strcat(path, ":");
559 (void) strcat(path, mn);
560
561 di_devfs_path_free(ptr);
562
563 if (devfsadm_enumerate_int(path, 0, &buf, rules, 1) != 0) {
564 return (DEVFSADM_CONTINUE);
565 }
566
567 (void) strcpy(path, "se_hdlc");
568 (void) strcat(path, buf);
569 free(buf);
570
571 (void) devfsadm_mklink(path, node, minor, 0);
572
573 return (DEVFSADM_CONTINUE);
574 }
575
576 static int
gpio(di_minor_t minor,di_node_t node)577 gpio(di_minor_t minor, di_node_t node)
578 {
579 char l_path[PATH_MAX], p_path[PATH_MAX], *buf, *devfspath;
580 char *minor_nm, *drvr_nm;
581
582
583 minor_nm = di_minor_name(minor);
584 drvr_nm = di_driver_name(node);
585 if ((minor_nm == NULL) || (drvr_nm == NULL)) {
586 return (DEVFSADM_CONTINUE);
587 }
588
589 devfspath = di_devfs_path(node);
590
591 (void) strcpy(p_path, devfspath);
592 (void) strcat(p_path, ":");
593 (void) strcat(p_path, minor_nm);
594 di_devfs_path_free(devfspath);
595
596 /* build the physical path from the components */
597 if (devfsadm_enumerate_int(p_path, 0, &buf, gpio_rules, 1)) {
598 return (DEVFSADM_CONTINUE);
599 }
600
601 (void) snprintf(l_path, sizeof (l_path), "%s%s", "gpio", buf);
602
603 free(buf);
604
605 (void) devfsadm_mklink(l_path, node, minor, 0);
606
607 return (DEVFSADM_CONTINUE);
608 }
609
610 /*
611 * Creates /dev/ppm nodes for Platform Specific PM module
612 */
613 static int
ppm(di_minor_t minor,di_node_t node)614 ppm(di_minor_t minor, di_node_t node)
615 {
616 (void) devfsadm_mklink("ppm", node, minor, 0);
617 return (DEVFSADM_CONTINUE);
618 }
619
620 /*
621 * Handles:
622 * /dev/av/[0-9]+/(async|isoch)
623 */
624 static int
av_create(di_minor_t minor,di_node_t node)625 av_create(di_minor_t minor, di_node_t node)
626 {
627 devfsadm_enumerate_t rules[1] = {"^av$/^([0-9]+)$", 1, MATCH_ADDR};
628 char *minor_str;
629 char path[PATH_MAX + 1];
630 char *buf;
631
632 if ((buf = di_devfs_path(node)) == NULL) {
633 return (DEVFSADM_CONTINUE);
634 }
635
636 minor_str = di_minor_name(minor);
637 (void) snprintf(path, sizeof (path), "%s:%s", buf, minor_str);
638 di_devfs_path_free(buf);
639
640 if (devfsadm_enumerate_int(path, 0, &buf, rules, 1)) {
641 return (DEVFSADM_CONTINUE);
642 }
643
644 (void) snprintf(path, sizeof (path), "av/%s/%s", buf, minor_str);
645 free(buf);
646
647 (void) devfsadm_mklink(path, node, minor, 0);
648
649 return (DEVFSADM_CONTINUE);
650 }
651
652 /*
653 * Create device nodes for Virtio 9P channels:
654 * /dev/9p/[0-9]+
655 */
656 static int
vio9p_create(di_minor_t minor,di_node_t node)657 vio9p_create(di_minor_t minor, di_node_t node)
658 {
659 char *minor_name = di_minor_name(minor);
660 char path[PATH_MAX + 1];
661
662 if (minor_name == NULL || strcmp(minor_name, "9p") != 0) {
663 return (DEVFSADM_CONTINUE);
664 }
665
666 (void) snprintf(path, sizeof (path), "9p/%d", di_instance(node));
667 (void) devfsadm_mklink(path, node, minor, 0);
668
669 return (DEVFSADM_CONTINUE);
670 }
671
672 /*
673 * Creates /dev/lom and /dev/tsalarm:ctl for tsalarm node
674 */
675 static int
tsalarm_create(di_minor_t minor,di_node_t node)676 tsalarm_create(di_minor_t minor, di_node_t node)
677 {
678 char buf[PATH_MAX + 1];
679 char *mn = di_minor_name(minor);
680
681 (void) snprintf(buf, sizeof (buf), "%s%s", di_node_name(node), ":ctl");
682
683 (void) devfsadm_mklink(mn, node, minor, 0);
684 (void) devfsadm_mklink(buf, node, minor, 0);
685
686 return (DEVFSADM_CONTINUE);
687 }
688
689 /*
690 * Creates /dev/ntwdt for ntwdt node
691 */
692 static int
ntwdt_create(di_minor_t minor,di_node_t node)693 ntwdt_create(di_minor_t minor, di_node_t node)
694 {
695 (void) devfsadm_mklink("ntwdt", node, minor, 0);
696 return (DEVFSADM_CONTINUE);
697 }
698
699 static int
zcons_create(di_minor_t minor,di_node_t node)700 zcons_create(di_minor_t minor, di_node_t node)
701 {
702 char *minor_str;
703 char *zonename;
704 char path[MAXPATHLEN];
705
706 minor_str = di_minor_name(minor);
707
708 if (di_prop_lookup_strings(DDI_DEV_T_ANY, node, "zonename",
709 &zonename) == -1) {
710 return (DEVFSADM_CONTINUE);
711 }
712
713 (void) snprintf(path, sizeof (path), "zcons/%s/%s", zonename,
714 minor_str);
715 (void) devfsadm_mklink(path, node, minor, 0);
716
717 return (DEVFSADM_CONTINUE);
718 }
719
720 /*
721 * /dev/cpu/self/cpuid -> /devices/pseudo/cpuid@0:self
722 */
723 static int
cpuid(di_minor_t minor,di_node_t node)724 cpuid(di_minor_t minor, di_node_t node)
725 {
726 (void) devfsadm_mklink(CPUID_SELF_NAME, node, minor, 0);
727 return (DEVFSADM_CONTINUE);
728 }
729
730 /*
731 * For device
732 * /dev/spfma -> /devices/virtual-devices/fma@5:glvc
733 */
734 static int
glvc(di_minor_t minor,di_node_t node)735 glvc(di_minor_t minor, di_node_t node)
736 {
737 char node_name[MAXNAMELEN + 1];
738
739 (void) strcpy(node_name, di_node_name(node));
740
741 if (strncmp(node_name, "fma", 3) == 0) {
742 /* Only one fma channel */
743 (void) devfsadm_mklink("spfma", node, minor, 0);
744 }
745 return (DEVFSADM_CONTINUE);
746 }
747
748 /*
749 * Handles links of the form:
750 * type=ddi_pseudo;name=sckmdrv kmdrv\M0
751 * type=ddi_pseudo;name=oplkmdrv kmdrv\M0
752 */
753 static int
kmdrv_create(di_minor_t minor,di_node_t node)754 kmdrv_create(di_minor_t minor, di_node_t node)
755 {
756
757 (void) devfsadm_mklink("kmdrv", node, minor, 0);
758 return (DEVFSADM_CONTINUE);
759 }
760
761 /*
762 * EEPROMs
763 *
764 * Minor nodes are named by the eedev driver as <driver>:<instance>:<name>. Our
765 * goal is to turn this into /dev/eeprom/driver/instance/name -> /devices/...
766 */
767 static int
eeprom_create(di_minor_t minor,di_node_t node)768 eeprom_create(di_minor_t minor, di_node_t node)
769 {
770 const char *n;
771 char *dup, *c;
772 char buf[PATH_MAX];
773
774 if ((n = di_minor_name(minor)) == NULL) {
775 return (DEVFSADM_CONTINUE);
776 }
777
778 if ((dup = strdup(n)) == NULL) {
779 return (DEVFSADM_TERMINATE);
780 }
781
782 c = dup;
783 while ((c = strchr(c, ':')) != NULL) {
784 *c = '/';
785 }
786
787 if (snprintf(buf, sizeof (buf), "eeprom/%s", dup) < sizeof (buf)) {
788 (void) devfsadm_mklink(buf, node, minor, 0);
789 }
790
791 free(dup);
792 return (DEVFSADM_CONTINUE);
793 }
794