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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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