xref: /freebsd/sys/compat/linsysfs/linsysfs.c (revision f6a3b357e9be4c6423c85eff9a847163a0d307c8)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 2006 IronPort Systems
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  */
28 
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
31 
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/ctype.h>
35 #include <sys/kernel.h>
36 #include <sys/malloc.h>
37 #include <sys/mount.h>
38 #include <sys/sbuf.h>
39 #include <sys/smp.h>
40 #include <sys/socket.h>
41 #include <sys/bus.h>
42 #include <sys/pciio.h>
43 
44 #include <dev/pci/pcivar.h>
45 #include <dev/pci/pcireg.h>
46 
47 #include <net/if.h>
48 #include <net/if_var.h>
49 #include <net/if_dl.h>
50 
51 #include <compat/linux/linux.h>
52 #include <compat/linux/linux_common.h>
53 #include <compat/linux/linux_util.h>
54 #include <fs/pseudofs/pseudofs.h>
55 
56 struct scsi_host_queue {
57 	TAILQ_ENTRY(scsi_host_queue) scsi_host_next;
58 	char *path;
59 	char *name;
60 };
61 
62 TAILQ_HEAD(,scsi_host_queue) scsi_host_q;
63 
64 static int host_number = 0;
65 
66 static int
67 atoi(const char *str)
68 {
69 	return (int)strtol(str, (char **)NULL, 10);
70 }
71 
72 static int
73 linsysfs_ifnet_addr(PFS_FILL_ARGS)
74 {
75 	struct l_sockaddr lsa;
76 	struct ifnet *ifp;
77 
78 	ifp = ifname_linux_to_bsd(td, pn->pn_parent->pn_name, NULL);
79 	if (ifp == NULL)
80 		return (ENOENT);
81 	if (linux_ifhwaddr(ifp, &lsa) != 0)
82 		return (ENOENT);
83 	sbuf_printf(sb, "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx\n",
84 	    lsa.sa_data[0], lsa.sa_data[1], lsa.sa_data[2],
85 	    lsa.sa_data[3], lsa.sa_data[4], lsa.sa_data[5]);
86 	return (0);
87 }
88 
89 static int
90 linsysfs_ifnet_addrlen(PFS_FILL_ARGS)
91 {
92 
93 	sbuf_printf(sb, "%d\n", LINUX_IFHWADDRLEN);
94 	return (0);
95 }
96 
97 static int
98 linsysfs_ifnet_flags(PFS_FILL_ARGS)
99 {
100 	struct ifnet *ifp;
101 	unsigned short flags;
102 
103 	ifp = ifname_linux_to_bsd(td, pn->pn_parent->pn_name, NULL);
104 	if (ifp == NULL)
105 		return (ENOENT);
106 	linux_ifflags(ifp, &flags);
107 	sbuf_printf(sb, "0x%x\n", flags);
108 	return (0);
109 }
110 
111 static int
112 linsysfs_ifnet_ifindex(PFS_FILL_ARGS)
113 {
114 	struct ifnet *ifp;
115 
116 	ifp = ifname_linux_to_bsd(td, pn->pn_parent->pn_name, NULL);
117 	if (ifp == NULL)
118 		return (ENOENT);
119 	sbuf_printf(sb, "%u\n", ifp->if_index);
120 	return (0);
121 }
122 
123 static int
124 linsysfs_ifnet_mtu(PFS_FILL_ARGS)
125 {
126 	struct ifnet *ifp;
127 
128 	ifp = ifname_linux_to_bsd(td, pn->pn_parent->pn_name, NULL);
129 	if (ifp == NULL)
130 		return (ENOENT);
131 	sbuf_printf(sb, "%u\n", ifp->if_mtu);
132 	return (0);
133 }
134 
135 static int
136 linsysfs_ifnet_tx_queue_len(PFS_FILL_ARGS)
137 {
138 
139 	/* XXX */
140 	sbuf_printf(sb, "1000\n");
141 	return (0);
142 }
143 
144 static int
145 linsysfs_ifnet_type(PFS_FILL_ARGS)
146 {
147 	struct l_sockaddr lsa;
148 	struct ifnet *ifp;
149 
150 	ifp = ifname_linux_to_bsd(td, pn->pn_parent->pn_name, NULL);
151 	if (ifp == NULL)
152 		return (ENOENT);
153 	if (linux_ifhwaddr(ifp, &lsa) != 0)
154 		return (ENOENT);
155 	sbuf_printf(sb, "%d\n", lsa.sa_family);
156 	return (0);
157 }
158 
159 static void
160 linsysfs_listnics(struct pfs_node *dir)
161 {
162 	struct pfs_node *nic;
163 	struct pfs_node *lo;
164 
165 	nic = pfs_create_dir(dir, "eth0", NULL, NULL, NULL, 0);
166 
167 	pfs_create_file(nic, "address", &linsysfs_ifnet_addr,
168 	    NULL, NULL, NULL, PFS_RD);
169 
170 	pfs_create_file(nic, "addr_len", &linsysfs_ifnet_addrlen,
171 	    NULL, NULL, NULL, PFS_RD);
172 
173 	pfs_create_file(nic, "flags", &linsysfs_ifnet_flags,
174 	    NULL, NULL, NULL, PFS_RD);
175 
176 	pfs_create_file(nic, "ifindex", &linsysfs_ifnet_ifindex,
177 	    NULL, NULL, NULL, PFS_RD);
178 
179 	pfs_create_file(nic, "mtu", &linsysfs_ifnet_mtu,
180 	    NULL, NULL, NULL, PFS_RD);
181 
182 	pfs_create_file(nic, "tx_queue_len", &linsysfs_ifnet_tx_queue_len,
183 	    NULL, NULL, NULL, PFS_RD);
184 
185 	pfs_create_file(nic, "type", &linsysfs_ifnet_type,
186 	    NULL, NULL, NULL, PFS_RD);
187 
188 	lo = pfs_create_dir(dir, "lo", NULL, NULL, NULL, 0);
189 
190 	pfs_create_file(lo, "address", &linsysfs_ifnet_addr,
191 	    NULL, NULL, NULL, PFS_RD);
192 
193 	pfs_create_file(lo, "addr_len", &linsysfs_ifnet_addrlen,
194 	    NULL, NULL, NULL, PFS_RD);
195 
196 	pfs_create_file(lo, "flags", &linsysfs_ifnet_flags,
197 	    NULL, NULL, NULL, PFS_RD);
198 
199 	pfs_create_file(lo, "ifindex", &linsysfs_ifnet_ifindex,
200 	    NULL, NULL, NULL, PFS_RD);
201 
202 	pfs_create_file(lo, "mtu", &linsysfs_ifnet_mtu,
203 	    NULL, NULL, NULL, PFS_RD);
204 
205 	pfs_create_file(lo, "tx_queue_len", &linsysfs_ifnet_tx_queue_len,
206 	    NULL, NULL, NULL, PFS_RD);
207 
208 	pfs_create_file(lo, "type", &linsysfs_ifnet_type,
209 	    NULL, NULL, NULL, PFS_RD);
210 }
211 
212 /*
213  * Filler function for proc_name
214  */
215 static int
216 linsysfs_scsiname(PFS_FILL_ARGS)
217 {
218 	struct scsi_host_queue *scsi_host;
219 	int index;
220 
221 	if (strncmp(pn->pn_parent->pn_name, "host", 4) == 0) {
222 		index = atoi(&pn->pn_parent->pn_name[4]);
223 	} else {
224 		sbuf_printf(sb, "unknown\n");
225 		return (0);
226 	}
227 	TAILQ_FOREACH(scsi_host, &scsi_host_q, scsi_host_next) {
228 		if (index-- == 0) {
229 			sbuf_printf(sb, "%s\n", scsi_host->name);
230 			return (0);
231 		}
232 	}
233 	sbuf_printf(sb, "unknown\n");
234 	return (0);
235 }
236 
237 /*
238  * Filler function for device sym-link
239  */
240 static int
241 linsysfs_link_scsi_host(PFS_FILL_ARGS)
242 {
243 	struct scsi_host_queue *scsi_host;
244 	int index;
245 
246 	if (strncmp(pn->pn_parent->pn_name, "host", 4) == 0) {
247 		index = atoi(&pn->pn_parent->pn_name[4]);
248 	} else {
249 		sbuf_printf(sb, "unknown\n");
250 		return (0);
251 	}
252 	TAILQ_FOREACH(scsi_host, &scsi_host_q, scsi_host_next) {
253 		if (index-- == 0) {
254 			sbuf_printf(sb, "../../../devices%s", scsi_host->path);
255 			return(0);
256 		}
257 	}
258 	sbuf_printf(sb, "unknown\n");
259 	return (0);
260 }
261 
262 static int
263 linsysfs_fill_data(PFS_FILL_ARGS)
264 {
265 	sbuf_printf(sb, "%s", (char *)pn->pn_data);
266 	return (0);
267 }
268 
269 static int
270 linsysfs_fill_vendor(PFS_FILL_ARGS)
271 {
272 	sbuf_printf(sb, "0x%04x\n", pci_get_vendor((device_t)pn->pn_data));
273 	return (0);
274 }
275 
276 static int
277 linsysfs_fill_device(PFS_FILL_ARGS)
278 {
279 	sbuf_printf(sb, "0x%04x\n", pci_get_device((device_t)pn->pn_data));
280 	return (0);
281 }
282 
283 static int
284 linsysfs_fill_subvendor(PFS_FILL_ARGS)
285 {
286 	sbuf_printf(sb, "0x%04x\n", pci_get_subvendor((device_t)pn->pn_data));
287 	return (0);
288 }
289 
290 static int
291 linsysfs_fill_subdevice(PFS_FILL_ARGS)
292 {
293 	sbuf_printf(sb, "0x%04x\n", pci_get_subdevice((device_t)pn->pn_data));
294 	return (0);
295 }
296 
297 static int
298 linsysfs_fill_revid(PFS_FILL_ARGS)
299 {
300 	sbuf_printf(sb, "0x%x\n", pci_get_revid((device_t)pn->pn_data));
301 	return (0);
302 }
303 
304 static int
305 linsysfs_fill_config(PFS_FILL_ARGS)
306 {
307 	uint8_t config[48];
308 	device_t dev;
309 	uint32_t reg;
310 
311 	dev = (device_t)pn->pn_data;
312 	bzero(config, sizeof(config));
313 	reg = pci_get_vendor(dev);
314 	config[0] = reg;
315 	config[1] = reg >> 8;
316 	reg = pci_get_device(dev);
317 	config[2] = reg;
318 	config[3] = reg >> 8;
319 	reg = pci_get_revid(dev);
320 	config[8] = reg;
321 	reg = pci_get_subvendor(dev);
322 	config[44] = reg;
323 	config[45] = reg >> 8;
324 	reg = pci_get_subdevice(dev);
325 	config[46] = reg;
326 	config[47] = reg >> 8;
327 	sbuf_bcat(sb, config, sizeof(config));
328 	return (0);
329 }
330 
331 /*
332  * Filler function for PCI uevent file
333  */
334 static int
335 linsysfs_fill_uevent_pci(PFS_FILL_ARGS)
336 {
337 	device_t dev;
338 
339 	dev = (device_t)pn->pn_data;
340 	sbuf_printf(sb, "DRIVER=%s\nPCI_CLASS=%X\nPCI_ID=%04X:%04X\n"
341 	    "PCI_SUBSYS_ID=%04X:%04X\nPCI_SLOT_NAME=%04d:%02x:%02x.%x\n",
342 	    linux_driver_get_name_dev(dev), pci_get_class(dev),
343 	    pci_get_vendor(dev), pci_get_device(dev), pci_get_subvendor(dev),
344 	    pci_get_subdevice(dev), pci_get_domain(dev), pci_get_bus(dev),
345 	    pci_get_slot(dev), pci_get_function(dev));
346 	return (0);
347 }
348 
349 /*
350  * Filler function for drm uevent file
351  */
352 static int
353 linsysfs_fill_uevent_drm(PFS_FILL_ARGS)
354 {
355 	device_t dev;
356 	int unit;
357 
358 	dev = (device_t)pn->pn_data;
359 	unit = device_get_unit(dev);
360 	sbuf_printf(sb,
361 	    "MAJOR=226\nMINOR=%d\nDEVNAME=dri/card%d\nDEVTYPE=dri_minor\n",
362 	    unit, unit);
363 	return (0);
364 }
365 
366 static char *
367 get_full_pfs_path(struct pfs_node *cur)
368 {
369 	char *temp, *path;
370 
371 	temp = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
372 	path = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
373 	path[0] = '\0';
374 
375 	do {
376 		snprintf(temp, MAXPATHLEN, "%s/%s", cur->pn_name, path);
377 		strlcpy(path, temp, MAXPATHLEN);
378 		cur = cur->pn_parent;
379 	} while (cur->pn_parent != NULL);
380 
381 	path[strlen(path) - 1] = '\0'; /* remove extra slash */
382 	free(temp, M_TEMP);
383 	return (path);
384 }
385 
386 /*
387  * Filler function for symlink from drm char device to PCI device
388  */
389 static int
390 linsysfs_fill_vgapci(PFS_FILL_ARGS)
391 {
392 	char *path;
393 
394 	path = get_full_pfs_path((struct pfs_node*)pn->pn_data);
395 	sbuf_printf(sb, "../../../%s", path);
396 	free(path, M_TEMP);
397 	return (0);
398 }
399 
400 #undef PCI_DEV
401 #define PCI_DEV "pci"
402 #define DRMN_DEV "drmn"
403 static int
404 linsysfs_run_bus(device_t dev, struct pfs_node *dir, struct pfs_node *scsi,
405     struct pfs_node *chardev, struct pfs_node *drm, char *path, char *prefix)
406 {
407 	struct scsi_host_queue *scsi_host;
408 	struct pfs_node *sub_dir, *cur_file;
409 	int i, nchildren, error;
410 	device_t *children, parent;
411 	devclass_t devclass;
412 	const char *name = NULL;
413 	struct pci_devinfo *dinfo;
414 	char *device, *host, *new_path, *devname;
415 
416 	new_path = path;
417 	devname = malloc(16, M_TEMP, M_WAITOK);
418 
419 	parent = device_get_parent(dev);
420 	if (parent) {
421 		devclass = device_get_devclass(parent);
422 		if (devclass != NULL)
423 			name = devclass_get_name(devclass);
424 		if (name && strcmp(name, PCI_DEV) == 0) {
425 			dinfo = device_get_ivars(dev);
426 			if (dinfo) {
427 				device = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
428 				new_path = malloc(MAXPATHLEN, M_TEMP,
429 				    M_WAITOK);
430 				new_path[0] = '\000';
431 				strcpy(new_path, path);
432 				host = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
433 				device[0] = '\000';
434 				sprintf(device, "%s:%02x:%02x.%x",
435 				    prefix,
436 				    dinfo->cfg.bus,
437 				    dinfo->cfg.slot,
438 				    dinfo->cfg.func);
439 				strcat(new_path, "/");
440 				strcat(new_path, device);
441 				dir = pfs_create_dir(dir, device,
442 				    NULL, NULL, NULL, 0);
443 				cur_file = pfs_create_file(dir, "vendor",
444 				    &linsysfs_fill_vendor, NULL, NULL, NULL,
445 				    PFS_RD);
446 				cur_file->pn_data = (void*)dev;
447 				cur_file = pfs_create_file(dir, "device",
448 				    &linsysfs_fill_device, NULL, NULL, NULL,
449 				    PFS_RD);
450 				cur_file->pn_data = (void*)dev;
451 				cur_file = pfs_create_file(dir,
452 				    "subsystem_vendor",
453 				    &linsysfs_fill_subvendor, NULL, NULL, NULL,
454 				    PFS_RD);
455 				cur_file->pn_data = (void*)dev;
456 				cur_file = pfs_create_file(dir,
457 				    "subsystem_device",
458 				    &linsysfs_fill_subdevice, NULL, NULL, NULL,
459 				    PFS_RD);
460 				cur_file->pn_data = (void*)dev;
461 				cur_file = pfs_create_file(dir, "revision",
462 				    &linsysfs_fill_revid, NULL, NULL, NULL,
463 				    PFS_RD);
464 				cur_file->pn_data = (void*)dev;
465 				cur_file = pfs_create_file(dir, "config",
466 				    &linsysfs_fill_config, NULL, NULL, NULL,
467 				    PFS_RD);
468 				cur_file->pn_data = (void*)dev;
469 				cur_file = pfs_create_file(dir, "uevent",
470 				    &linsysfs_fill_uevent_pci, NULL, NULL,
471 				    NULL, PFS_RD);
472 				cur_file->pn_data = (void*)dev;
473 				cur_file = pfs_create_link(dir, "subsystem",
474 				    &linsysfs_fill_data, NULL, NULL, NULL, 0);
475 				/* libdrm just checks that the link ends in "/pci" */
476 				cur_file->pn_data = "/sys/bus/pci";
477 
478 				if (dinfo->cfg.baseclass == PCIC_STORAGE) {
479 					/* DJA only make this if needed */
480 					sprintf(host, "host%d", host_number++);
481 					strcat(new_path, "/");
482 					strcat(new_path, host);
483 					pfs_create_dir(dir, host,
484 					    NULL, NULL, NULL, 0);
485 					scsi_host = malloc(sizeof(
486 					    struct scsi_host_queue),
487 					    M_DEVBUF, M_NOWAIT);
488 					scsi_host->path = malloc(
489 					    strlen(new_path) + 1,
490 					    M_DEVBUF, M_NOWAIT);
491 					scsi_host->path[0] = '\000';
492 					bcopy(new_path, scsi_host->path,
493 					    strlen(new_path) + 1);
494 					scsi_host->name = "unknown";
495 
496 					sub_dir = pfs_create_dir(scsi, host,
497 					    NULL, NULL, NULL, 0);
498 					pfs_create_link(sub_dir, "device",
499 					    &linsysfs_link_scsi_host,
500 					    NULL, NULL, NULL, 0);
501 					pfs_create_file(sub_dir, "proc_name",
502 					    &linsysfs_scsiname,
503 					    NULL, NULL, NULL, PFS_RD);
504 					scsi_host->name
505 					    = linux_driver_get_name_dev(dev);
506 					TAILQ_INSERT_TAIL(&scsi_host_q,
507 					    scsi_host, scsi_host_next);
508 				}
509 				free(device, M_TEMP);
510 				free(host, M_TEMP);
511 			}
512 		}
513 
514 		devclass = device_get_devclass(dev);
515 		if (devclass != NULL)
516 			name = devclass_get_name(devclass);
517 		else
518 			name = NULL;
519 		if (name != NULL && strcmp(name, DRMN_DEV) == 0 &&
520 		    device_get_unit(dev) >= 0) {
521 			dinfo = device_get_ivars(parent);
522 			if (dinfo != NULL && dinfo->cfg.baseclass == PCIC_DISPLAY) {
523 				sprintf(devname, "226:%d",
524 				    device_get_unit(dev));
525 				sub_dir = pfs_create_dir(chardev,
526 				    devname, NULL, NULL, NULL, 0);
527 				cur_file = pfs_create_link(sub_dir,
528 				    "device", &linsysfs_fill_vgapci, NULL,
529 				    NULL, NULL, PFS_RD);
530 				cur_file->pn_data = (void*)dir;
531 				cur_file = pfs_create_file(sub_dir,
532 				    "uevent", &linsysfs_fill_uevent_drm, NULL,
533 				    NULL, NULL, PFS_RD);
534 				cur_file->pn_data = (void*)dev;
535 				sprintf(devname, "card%d",
536 				    device_get_unit(dev));
537 				sub_dir = pfs_create_dir(drm,
538 				    devname, NULL, NULL, NULL, 0);
539 				cur_file = pfs_create_link(sub_dir,
540 				    "device", &linsysfs_fill_vgapci, NULL,
541 				    NULL, NULL, PFS_RD);
542 				cur_file->pn_data = (void*)dir;
543 			}
544 		}
545 	}
546 
547 	error = device_get_children(dev, &children, &nchildren);
548 	if (error == 0) {
549 		for (i = 0; i < nchildren; i++)
550 			if (children[i])
551 				linsysfs_run_bus(children[i], dir, scsi,
552 				    chardev, drm, new_path, prefix);
553 		free(children, M_TEMP);
554 	}
555 	if (new_path != path)
556 		free(new_path, M_TEMP);
557 	free(devname, M_TEMP);
558 
559 	return (1);
560 }
561 
562 /*
563  * Filler function for sys/devices/system/cpu/{online,possible,present}
564  */
565 static int
566 linsysfs_cpuonline(PFS_FILL_ARGS)
567 {
568 
569 	sbuf_printf(sb, "%d-%d\n", CPU_FIRST(), mp_maxid);
570 	return (0);
571 }
572 
573 /*
574  * Filler function for sys/devices/system/cpu/cpuX/online
575  */
576 static int
577 linsysfs_cpuxonline(PFS_FILL_ARGS)
578 {
579 
580 	sbuf_printf(sb, "1\n");
581 	return (0);
582 }
583 
584 static void
585 linsysfs_listcpus(struct pfs_node *dir)
586 {
587 	struct pfs_node *cpu;
588 	char *name;
589 	int i, count, len;
590 
591 	len = 1;
592 	count = mp_maxcpus;
593 	while (count > 10) {
594 		count /= 10;
595 		len++;
596 	}
597 	len += sizeof("cpu");
598 	name = malloc(len, M_TEMP, M_WAITOK);
599 
600 	for (i = 0; i < mp_ncpus; ++i) {
601 		/* /sys/devices/system/cpu/cpuX */
602 		sprintf(name, "cpu%d", i);
603 		cpu = pfs_create_dir(dir, name, NULL, NULL, NULL, 0);
604 
605 		pfs_create_file(cpu, "online", &linsysfs_cpuxonline,
606 		    NULL, NULL, NULL, PFS_RD);
607 	}
608 	free(name, M_TEMP);
609 }
610 
611 /*
612  * Constructor
613  */
614 static int
615 linsysfs_init(PFS_INIT_ARGS)
616 {
617 	struct pfs_node *root;
618 	struct pfs_node *class;
619 	struct pfs_node *dir, *sys, *cpu;
620 	struct pfs_node *drm;
621 	struct pfs_node *pci;
622 	struct pfs_node *scsi;
623 	struct pfs_node *net;
624 	struct pfs_node *devdir, *chardev;
625 	devclass_t devclass;
626 	device_t dev;
627 
628 	TAILQ_INIT(&scsi_host_q);
629 
630 	root = pi->pi_root;
631 
632 	/* /sys/class/... */
633 	class = pfs_create_dir(root, "class", NULL, NULL, NULL, 0);
634 	scsi = pfs_create_dir(class, "scsi_host", NULL, NULL, NULL, 0);
635 	drm = pfs_create_dir(class, "drm", NULL, NULL, NULL, 0);
636 
637 	/* /sys/class/net/.. */
638 	net = pfs_create_dir(class, "net", NULL, NULL, NULL, 0);
639 
640 	/* /sys/dev/... */
641 	devdir = pfs_create_dir(root, "dev", NULL, NULL, NULL, 0);
642 	chardev = pfs_create_dir(devdir, "char", NULL, NULL, NULL, 0);
643 
644 	/* /sys/devices/... */
645 	dir = pfs_create_dir(root, "devices", NULL, NULL, NULL, 0);
646 	pci = pfs_create_dir(dir, "pci0000:00", NULL, NULL, NULL, 0);
647 
648 	devclass = devclass_find("root");
649 	if (devclass == NULL) {
650 		return (0);
651 	}
652 
653 	dev = devclass_get_device(devclass, 0);
654 	linsysfs_run_bus(dev, pci, scsi, chardev, drm, "/pci0000:00", "0000");
655 
656 	/* /sys/devices/system */
657 	sys = pfs_create_dir(dir, "system", NULL, NULL, NULL, 0);
658 
659 	/* /sys/devices/system/cpu */
660 	cpu = pfs_create_dir(sys, "cpu", NULL, NULL, NULL, 0);
661 
662 	pfs_create_file(cpu, "online", &linsysfs_cpuonline,
663 	    NULL, NULL, NULL, PFS_RD);
664 	pfs_create_file(cpu, "possible", &linsysfs_cpuonline,
665 	    NULL, NULL, NULL, PFS_RD);
666 	pfs_create_file(cpu, "present", &linsysfs_cpuonline,
667 	    NULL, NULL, NULL, PFS_RD);
668 
669 	linsysfs_listcpus(cpu);
670 	linsysfs_listnics(net);
671 
672 	return (0);
673 }
674 
675 /*
676  * Destructor
677  */
678 static int
679 linsysfs_uninit(PFS_INIT_ARGS)
680 {
681 	struct scsi_host_queue *scsi_host, *scsi_host_tmp;
682 
683 	TAILQ_FOREACH_SAFE(scsi_host, &scsi_host_q, scsi_host_next,
684 	    scsi_host_tmp) {
685 		TAILQ_REMOVE(&scsi_host_q, scsi_host, scsi_host_next);
686 		free(scsi_host->path, M_TEMP);
687 		free(scsi_host, M_TEMP);
688 	}
689 
690 	return (0);
691 }
692 
693 PSEUDOFS(linsysfs, 1, VFCF_JAIL);
694 #if defined(__aarch64__) || defined(__amd64__)
695 MODULE_DEPEND(linsysfs, linux_common, 1, 1, 1);
696 #else
697 MODULE_DEPEND(linsysfs, linux, 1, 1, 1);
698 #endif
699