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