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