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