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$)|(^dccp$)|"
 105             "(^ip6$)|(^tcp6$)|(^udp6$)|(^icmp6$)|(^dccp6$)|"
 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 }