usr/src/cmd/devfsadm/misc_link.c

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