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