Print this page
OS-7667 IPFilter needs to keep and report state for cloud firewall logging
Portions contributed by: Mike Gerdts <mike.gerdts@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
|
↓ open down ↓ |
13 lines elided |
↑ open up ↑ |
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 - * Copyright (c) 2015, Joyent, Inc. All rights reserved.
24 + * Copyright 2019 Joyent, Inc.
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$)",
|
↓ open down ↓ |
82 lines elided |
↑ open up ↑ |
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 - "(^ipsync$)|(^ipscan$)|(^iplookup$)",
127 + "(^ipsync$)|(^ipscan$)|(^iplookup$)|(^ipfev$)",
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,
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 215 { "pseudo", "ddi_pseudo", "overlay",
216 216 TYPE_EXACT | DRV_EXACT, ILEVEL_0, minor_name
217 217 }
218 218 };
219 219
220 220 DEVFSADM_CREATE_INIT_V0(misc_cbt);
221 221
222 222 static devfsadm_remove_t misc_remove_cbt[] = {
223 223 { "pseudo", "^profile$",
224 224 RM_PRE | RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
225 225 },
226 226 { "pseudo", "^rsm$",
227 227 RM_PRE | RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
228 228 },
229 229 { "printer", "^printers/[0-9]+$",
230 230 RM_PRE | RM_HOT | RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
231 231 },
232 232 { "av", "^av/[0-9]+/(async|isoch)$",
233 233 RM_PRE | RM_HOT | RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
234 234 },
235 235 { "pseudo", "^daplt$",
236 236 RM_PRE | RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
237 237 },
238 238 { "pseudo", "^zcons/" ZONENAME_REGEXP "/(" ZCONS_MASTER_NAME "|"
239 239 ZCONS_SLAVE_NAME ")$",
240 240 RM_PRE | RM_HOT | RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
241 241 },
242 242 { "pseudo", "^zfd/" ZONENAME_REGEXP "/(master|slave)/[0-9]+$",
243 243 RM_PRE | RM_HOT | RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
244 244 },
245 245 { "pseudo", "^" CPUID_SELF_NAME "$", RM_ALWAYS | RM_PRE | RM_HOT,
246 246 ILEVEL_0, devfsadm_rm_all
247 247 },
248 248 { "enclosure", "^es/ses[0-9]+$", RM_POST,
249 249 ILEVEL_0, devfsadm_rm_all
250 250 },
251 251 { "pseudo", "^pfil$",
252 252 RM_PRE | RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
253 253 },
254 254 { "pseudo", "^tpm$",
255 255 RM_PRE | RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
256 256 },
257 257 { "pseudo", "^sctp|sctp6$",
258 258 RM_PRE | RM_ALWAYS, ILEVEL_0, devfsadm_rm_link
259 259 }
260 260 };
261 261
262 262 /* Rules for gpio devices */
263 263 static devfsadm_enumerate_t gpio_rules[1] =
264 264 {"^gpio([0-9]+)$", 1, MATCH_ALL};
265 265
266 266 DEVFSADM_REMOVE_INIT_V0(misc_remove_cbt);
267 267
268 268 /*
269 269 * Handles minor node type "ddi_display".
270 270 *
271 271 * type=ddi_display fbs/\M0 fb\N0
272 272 */
273 273 static int
274 274 display(di_minor_t minor, di_node_t node)
275 275 {
276 276 char l_path[PATH_MAX + 1], contents[PATH_MAX + 1], *buf;
277 277 devfsadm_enumerate_t rules[1] = {"^fb([0-9]+)$", 1, MATCH_ALL};
278 278 char *mn = di_minor_name(minor);
279 279
280 280 /* create fbs/\M0 primary link */
281 281 (void) strcpy(l_path, "fbs/");
282 282 (void) strcat(l_path, mn);
283 283 (void) devfsadm_mklink(l_path, node, minor, 0);
284 284
285 285 /* create fb\N0 which links to fbs/\M0 */
286 286 if (devfsadm_enumerate_int(l_path, 0, &buf, rules, 1)) {
287 287 return (DEVFSADM_CONTINUE);
288 288 }
289 289 (void) strcpy(contents, l_path);
290 290 (void) strcpy(l_path, "fb");
291 291 (void) strcat(l_path, buf);
292 292 free(buf);
293 293 (void) devfsadm_secondary_link(l_path, contents, 0);
294 294 return (DEVFSADM_CONTINUE);
295 295 }
296 296
297 297 /*
298 298 * Handles minor node type "ddi_parallel".
299 299 * type=ddi_parallel;name=mcpp mcpp\N0
300 300 */
301 301 static int
302 302 parallel(di_minor_t minor, di_node_t node)
303 303 {
304 304 char path[PATH_MAX + 1], *buf;
305 305 devfsadm_enumerate_t rules[1] = {"mcpp([0-9]+)$", 1, MATCH_ALL};
306 306
307 307
308 308 if (strcmp(di_node_name(node), "mcpp") != 0) {
309 309 return (DEVFSADM_CONTINUE);
310 310 }
311 311
312 312 if (NULL == (buf = di_devfs_path(node))) {
313 313 return (DEVFSADM_CONTINUE);
314 314 }
315 315
316 316 (void) snprintf(path, sizeof (path), "%s:%s",
317 317 buf, di_minor_name(minor));
318 318
319 319 di_devfs_path_free(buf);
320 320
321 321 if (devfsadm_enumerate_int(path, 0, &buf, rules, 1)) {
322 322 return (DEVFSADM_CONTINUE);
323 323 }
324 324 (void) snprintf(path, sizeof (path), "mcpp%s", buf);
325 325 free(buf);
326 326
327 327 (void) devfsadm_mklink(path, node, minor, 0);
328 328 return (DEVFSADM_CONTINUE);
329 329 }
330 330
331 331 static int
332 332 ses_callback(di_minor_t minor, di_node_t node)
333 333 {
334 334 char l_path[PATH_MAX];
335 335 char *buf;
336 336 char *devfspath;
337 337 char p_path[PATH_MAX];
338 338 devfsadm_enumerate_t re[] = {"^es$/^ses([0-9]+)$", 1, MATCH_ALL};
339 339
340 340 /* find devices path -- need to free mem */
341 341 if (NULL == (devfspath = di_devfs_path(node))) {
342 342 return (DEVFSADM_CONTINUE);
343 343 }
344 344
345 345 (void) snprintf(p_path, sizeof (p_path), "%s:%s", devfspath,
346 346 di_minor_name(minor));
347 347
348 348
349 349 /* find next number to use; buf is an ascii number */
350 350 if (devfsadm_enumerate_int(p_path, 0, &buf, re, 1)) {
351 351 /* free memory */
352 352 di_devfs_path_free(devfspath);
353 353 return (DEVFSADM_CONTINUE);
354 354 }
355 355
356 356 (void) snprintf(l_path, sizeof (l_path), "es/ses%s", buf);
357 357
358 358 (void) devfsadm_mklink(l_path, node, minor, 0);
359 359 /* free memory */
360 360 free(buf);
361 361 di_devfs_path_free(devfspath);
362 362 return (DEVFSADM_CONTINUE);
363 363
364 364 }
365 365
366 366 static int
367 367 node_slash_minor(di_minor_t minor, di_node_t node)
368 368 {
369 369
370 370 char path[PATH_MAX + 1];
371 371
372 372 (void) strcpy(path, di_node_name(node));
373 373 (void) strcat(path, "/");
374 374 (void) strcat(path, di_minor_name(minor));
375 375 (void) devfsadm_mklink(path, node, minor, 0);
376 376 return (DEVFSADM_CONTINUE);
377 377 }
378 378
379 379 static int
380 380 driver_minor(di_minor_t minor, di_node_t node)
381 381 {
382 382 char path[PATH_MAX + 1];
383 383
384 384 (void) strcpy(path, di_driver_name(node));
385 385 (void) strcat(path, di_minor_name(minor));
386 386 (void) devfsadm_mklink(path, node, minor, 0);
387 387 return (DEVFSADM_CONTINUE);
388 388 }
389 389
390 390 /*
391 391 * Handles links of the form:
392 392 * type=ddi_pseudo;name=xyz \D
393 393 */
394 394 static int
395 395 node_name(di_minor_t minor, di_node_t node)
396 396 {
397 397 (void) devfsadm_mklink(di_node_name(node), node, minor, 0);
398 398 return (DEVFSADM_CONTINUE);
399 399 }
400 400
401 401 /*
402 402 * Handles links of the form:
403 403 * type=ddi_pseudo;name=xyz \M0
404 404 */
405 405 static int
406 406 minor_name(di_minor_t minor, di_node_t node)
407 407 {
408 408 char *mn = di_minor_name(minor);
409 409
410 410 (void) devfsadm_mklink(mn, node, minor, 0);
411 411 if (strcmp(mn, "icmp") == 0) {
412 412 (void) devfsadm_mklink("rawip", node, minor, 0);
413 413 }
414 414 if (strcmp(mn, "icmp6") == 0) {
415 415 (void) devfsadm_mklink("rawip6", node, minor, 0);
416 416 }
417 417 if (strcmp(mn, "ipf") == 0) {
418 418 (void) devfsadm_mklink("ipl", node, minor, 0);
419 419 }
420 420 return (DEVFSADM_CONTINUE);
421 421 }
422 422
423 423 /*
424 424 * create links at /dev/wifi for wifi minor node
425 425 */
426 426 static int
427 427 wifi_minor_name(di_minor_t minor, di_node_t node)
428 428 {
429 429 char buf[256];
430 430 char *mn = di_minor_name(minor);
431 431
432 432 (void) snprintf(buf, sizeof (buf), "%s%s", "wifi/", mn);
433 433 (void) devfsadm_mklink(buf, node, minor, 0);
434 434
435 435 return (DEVFSADM_CONTINUE);
436 436 }
437 437
438 438 static int
439 439 conskbd(di_minor_t minor, di_node_t node)
440 440 {
441 441 (void) devfsadm_mklink("kbd", node, minor, 0);
442 442 return (DEVFSADM_CONTINUE);
443 443 }
444 444
445 445 static int
446 446 consms(di_minor_t minor, di_node_t node)
447 447 {
448 448 (void) devfsadm_mklink("mouse", node, minor, 0);
449 449 return (DEVFSADM_CONTINUE);
450 450 }
451 451
452 452 static int
453 453 power_button(di_minor_t minor, di_node_t node)
454 454 {
455 455 (void) devfsadm_mklink("power_button", node, minor, 0);
456 456 return (DEVFSADM_CONTINUE);
457 457 }
458 458
459 459 static int
460 460 fc_port(di_minor_t minor, di_node_t node)
461 461 {
462 462 devfsadm_enumerate_t rules[1] = {"fc/fp([0-9]+)$", 1, MATCH_ALL};
463 463 char *buf, path[PATH_MAX + 1];
464 464 char *ptr;
465 465
466 466 if (NULL == (ptr = di_devfs_path(node))) {
467 467 return (DEVFSADM_CONTINUE);
468 468 }
469 469
470 470 (void) strcpy(path, ptr);
471 471 (void) strcat(path, ":");
472 472 (void) strcat(path, di_minor_name(minor));
473 473
474 474 di_devfs_path_free(ptr);
475 475
476 476 if (devfsadm_enumerate_int(path, 0, &buf, rules, 1) != 0) {
477 477 return (DEVFSADM_CONTINUE);
478 478 }
479 479
480 480 (void) strcpy(path, "fc/fp");
481 481 (void) strcat(path, buf);
482 482 free(buf);
483 483
484 484 (void) devfsadm_mklink(path, node, minor, 0);
485 485 return (DEVFSADM_CONTINUE);
486 486 }
487 487
488 488 /*
489 489 * Handles:
490 490 * minor node type "ddi_printer".
491 491 * rules of the form: type=ddi_printer;name=bpp \M0
492 492 */
493 493 static int
494 494 printer_create(di_minor_t minor, di_node_t node)
495 495 {
496 496 char *mn;
497 497 char path[PATH_MAX + 1], *buf;
498 498 devfsadm_enumerate_t rules[1] = {"^printers$/^([0-9]+)$", 1, MATCH_ALL};
499 499
500 500 mn = di_minor_name(minor);
501 501
502 502 if (strcmp(di_driver_name(node), "bpp") == 0) {
503 503 (void) devfsadm_mklink(mn, node, minor, 0);
504 504 }
505 505
506 506 if (NULL == (buf = di_devfs_path(node))) {
507 507 return (DEVFSADM_CONTINUE);
508 508 }
509 509
510 510 (void) snprintf(path, sizeof (path), "%s:%s", buf, mn);
511 511 di_devfs_path_free(buf);
512 512
513 513 if (devfsadm_enumerate_int(path, 0, &buf, rules, 1)) {
514 514 return (DEVFSADM_CONTINUE);
515 515 }
516 516
517 517 (void) snprintf(path, sizeof (path), "printers/%s", buf);
518 518 free(buf);
519 519
520 520 (void) devfsadm_mklink(path, node, minor, 0);
521 521
522 522 return (DEVFSADM_CONTINUE);
523 523 }
524 524
525 525 /*
526 526 * Handles links of the form:
527 527 * type=ddi_pseudo;name=se;minor2=hdlc se_hdlc\N0
528 528 * type=ddi_pseudo;name=serial;minor2=hdlc se_hdlc\N0
529 529 */
530 530 static int
531 531 se_hdlc_create(di_minor_t minor, di_node_t node)
532 532 {
533 533 devfsadm_enumerate_t rules[1] = {"^se_hdlc([0-9]+)$", 1, MATCH_ALL};
534 534 char *buf, path[PATH_MAX + 1];
535 535 char *ptr;
536 536 char *mn;
537 537
538 538 mn = di_minor_name(minor);
539 539
540 540 /* minor node should be of the form: "?,hdlc" */
541 541 if (strcmp(mn + 1, ",hdlc") != 0) {
542 542 return (DEVFSADM_CONTINUE);
543 543 }
544 544
545 545 if (NULL == (ptr = di_devfs_path(node))) {
546 546 return (DEVFSADM_CONTINUE);
547 547 }
548 548
549 549 (void) strcpy(path, ptr);
550 550 (void) strcat(path, ":");
551 551 (void) strcat(path, mn);
552 552
553 553 di_devfs_path_free(ptr);
554 554
555 555 if (devfsadm_enumerate_int(path, 0, &buf, rules, 1) != 0) {
556 556 return (DEVFSADM_CONTINUE);
557 557 }
558 558
559 559 (void) strcpy(path, "se_hdlc");
560 560 (void) strcat(path, buf);
561 561 free(buf);
562 562
563 563 (void) devfsadm_mklink(path, node, minor, 0);
564 564
565 565 return (DEVFSADM_CONTINUE);
566 566 }
567 567
568 568 static int
569 569 gpio(di_minor_t minor, di_node_t node)
570 570 {
571 571 char l_path[PATH_MAX], p_path[PATH_MAX], *buf, *devfspath;
572 572 char *minor_nm, *drvr_nm;
573 573
574 574
575 575 minor_nm = di_minor_name(minor);
576 576 drvr_nm = di_driver_name(node);
577 577 if ((minor_nm == NULL) || (drvr_nm == NULL)) {
578 578 return (DEVFSADM_CONTINUE);
579 579 }
580 580
581 581 devfspath = di_devfs_path(node);
582 582
583 583 (void) strcpy(p_path, devfspath);
584 584 (void) strcat(p_path, ":");
585 585 (void) strcat(p_path, minor_nm);
586 586 di_devfs_path_free(devfspath);
587 587
588 588 /* build the physical path from the components */
589 589 if (devfsadm_enumerate_int(p_path, 0, &buf, gpio_rules, 1)) {
590 590 return (DEVFSADM_CONTINUE);
591 591 }
592 592
593 593 (void) snprintf(l_path, sizeof (l_path), "%s%s", "gpio", buf);
594 594
595 595 free(buf);
596 596
597 597 (void) devfsadm_mklink(l_path, node, minor, 0);
598 598
599 599 return (DEVFSADM_CONTINUE);
600 600 }
601 601
602 602 /*
603 603 * Creates /dev/ppm nodes for Platform Specific PM module
604 604 */
605 605 static int
606 606 ppm(di_minor_t minor, di_node_t node)
607 607 {
608 608 (void) devfsadm_mklink("ppm", node, minor, 0);
609 609 return (DEVFSADM_CONTINUE);
610 610 }
611 611
612 612 /*
613 613 * Handles:
614 614 * /dev/av/[0-9]+/(async|isoch)
615 615 */
616 616 static int
617 617 av_create(di_minor_t minor, di_node_t node)
618 618 {
619 619 devfsadm_enumerate_t rules[1] = {"^av$/^([0-9]+)$", 1, MATCH_ADDR};
620 620 char *minor_str;
621 621 char path[PATH_MAX + 1];
622 622 char *buf;
623 623
624 624 if ((buf = di_devfs_path(node)) == NULL) {
625 625 return (DEVFSADM_CONTINUE);
626 626 }
627 627
628 628 minor_str = di_minor_name(minor);
629 629 (void) snprintf(path, sizeof (path), "%s:%s", buf, minor_str);
630 630 di_devfs_path_free(buf);
631 631
632 632 if (devfsadm_enumerate_int(path, 0, &buf, rules, 1)) {
633 633 return (DEVFSADM_CONTINUE);
634 634 }
635 635
636 636 (void) snprintf(path, sizeof (path), "av/%s/%s", buf, minor_str);
637 637 free(buf);
638 638
639 639 (void) devfsadm_mklink(path, node, minor, 0);
640 640
641 641 return (DEVFSADM_CONTINUE);
642 642 }
643 643
644 644 /*
645 645 * Creates /dev/lom and /dev/tsalarm:ctl for tsalarm node
646 646 */
647 647 static int
648 648 tsalarm_create(di_minor_t minor, di_node_t node)
649 649 {
650 650 char buf[PATH_MAX + 1];
651 651 char *mn = di_minor_name(minor);
652 652
653 653 (void) snprintf(buf, sizeof (buf), "%s%s", di_node_name(node), ":ctl");
654 654
655 655 (void) devfsadm_mklink(mn, node, minor, 0);
656 656 (void) devfsadm_mklink(buf, node, minor, 0);
657 657
658 658 return (DEVFSADM_CONTINUE);
659 659 }
660 660
661 661 /*
662 662 * Creates /dev/ntwdt for ntwdt node
663 663 */
664 664 static int
665 665 ntwdt_create(di_minor_t minor, di_node_t node)
666 666 {
667 667 (void) devfsadm_mklink("ntwdt", node, minor, 0);
668 668 return (DEVFSADM_CONTINUE);
669 669 }
670 670
671 671 static int
672 672 zcons_create(di_minor_t minor, di_node_t node)
673 673 {
674 674 char *minor_str;
675 675 char *zonename;
676 676 char path[MAXPATHLEN];
677 677
678 678 minor_str = di_minor_name(minor);
679 679
680 680 if (di_prop_lookup_strings(DDI_DEV_T_ANY, node, "zonename",
681 681 &zonename) == -1) {
682 682 return (DEVFSADM_CONTINUE);
683 683 }
684 684
685 685 (void) snprintf(path, sizeof (path), "zcons/%s/%s", zonename,
686 686 minor_str);
687 687 (void) devfsadm_mklink(path, node, minor, 0);
688 688
689 689 return (DEVFSADM_CONTINUE);
690 690 }
691 691
692 692 static int
693 693 zfd_create(di_minor_t minor, di_node_t node)
694 694 {
695 695 char *minor_str;
696 696 char *zonename;
697 697 int *id;
698 698 char path[MAXPATHLEN];
699 699
700 700 minor_str = di_minor_name(minor);
701 701
702 702 if (di_prop_lookup_strings(DDI_DEV_T_ANY, node, "zfd_zname",
703 703 &zonename) == -1)
704 704 return (DEVFSADM_CONTINUE);
705 705
706 706 if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, "zfd_id", &id) == -1)
707 707 return (DEVFSADM_CONTINUE);
708 708
709 709 if (strncmp(minor_str, "slave", 5) == 0) {
710 710 (void) snprintf(path, sizeof (path), "zfd/%s/slave/%d",
711 711 zonename, id[0]);
712 712 } else {
713 713 (void) snprintf(path, sizeof (path), "zfd/%s/master/%d",
714 714 zonename, id[0]);
715 715 }
716 716 (void) devfsadm_mklink(path, node, minor, 0);
717 717
718 718 return (DEVFSADM_CONTINUE);
719 719 }
720 720
721 721 /*
722 722 * /dev/cpu/self/cpuid -> /devices/pseudo/cpuid@0:self
723 723 */
724 724 static int
725 725 cpuid(di_minor_t minor, di_node_t node)
726 726 {
727 727 (void) devfsadm_mklink(CPUID_SELF_NAME, node, minor, 0);
728 728 return (DEVFSADM_CONTINUE);
729 729 }
730 730
731 731 /*
732 732 * For device
733 733 * /dev/spfma -> /devices/virtual-devices/fma@5:glvc
734 734 */
735 735 static int
736 736 glvc(di_minor_t minor, di_node_t node)
737 737 {
738 738 char node_name[MAXNAMELEN + 1];
739 739
740 740 (void) strcpy(node_name, di_node_name(node));
741 741
742 742 if (strncmp(node_name, "fma", 3) == 0) {
743 743 /* Only one fma channel */
744 744 (void) devfsadm_mklink("spfma", node, minor, 0);
745 745 }
746 746 return (DEVFSADM_CONTINUE);
747 747 }
748 748
749 749 /*
750 750 * Handles links of the form:
751 751 * type=ddi_pseudo;name=sckmdrv kmdrv\M0
752 752 * type=ddi_pseudo;name=oplkmdrv kmdrv\M0
753 753 */
754 754 static int
755 755 kmdrv_create(di_minor_t minor, di_node_t node)
756 756 {
757 757
758 758 (void) devfsadm_mklink("kmdrv", node, minor, 0);
759 759 return (DEVFSADM_CONTINUE);
760 760 }
|
↓ open down ↓ |
623 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX