1 /*-
2 * Copyright (c) 2015 Dmitry Chagin <dchagin@FreeBSD.org>
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
23 * SUCH DAMAGE.
24 */
25
26 #include <sys/cdefs.h>
27 #include "opt_inet6.h"
28
29 #include <sys/param.h>
30 #include <sys/conf.h>
31 #include <sys/ctype.h>
32 #include <sys/file.h>
33 #include <sys/filedesc.h>
34 #include <sys/jail.h>
35 #include <sys/lock.h>
36 #include <sys/malloc.h>
37 #include <sys/poll.h>
38 #include <sys/proc.h>
39 #include <sys/signalvar.h>
40 #include <sys/socket.h>
41 #include <sys/socketvar.h>
42
43 #include <net/if.h>
44 #include <net/if_var.h>
45 #include <net/if_dl.h>
46 #include <net/if_types.h>
47 #include <netlink/netlink.h>
48
49 #include <sys/un.h>
50 #include <netinet/in.h>
51
52 #include <compat/linux/linux.h>
53 #include <compat/linux/linux_common.h>
54 #include <compat/linux/linux_mib.h>
55 #include <compat/linux/linux_util.h>
56
57 CTASSERT(LINUX_IFNAMSIZ == IFNAMSIZ);
58
59 static bool use_real_ifnames = false;
60 SYSCTL_BOOL(_compat_linux, OID_AUTO, use_real_ifnames, CTLFLAG_RWTUN,
61 &use_real_ifnames, 0,
62 "Use FreeBSD interface names instead of generating ethN aliases");
63
64 static int bsd_to_linux_sigtbl[LINUX_SIGTBLSZ] = {
65 LINUX_SIGHUP, /* SIGHUP */
66 LINUX_SIGINT, /* SIGINT */
67 LINUX_SIGQUIT, /* SIGQUIT */
68 LINUX_SIGILL, /* SIGILL */
69 LINUX_SIGTRAP, /* SIGTRAP */
70 LINUX_SIGABRT, /* SIGABRT */
71 0, /* SIGEMT */
72 LINUX_SIGFPE, /* SIGFPE */
73 LINUX_SIGKILL, /* SIGKILL */
74 LINUX_SIGBUS, /* SIGBUS */
75 LINUX_SIGSEGV, /* SIGSEGV */
76 LINUX_SIGSYS, /* SIGSYS */
77 LINUX_SIGPIPE, /* SIGPIPE */
78 LINUX_SIGALRM, /* SIGALRM */
79 LINUX_SIGTERM, /* SIGTERM */
80 LINUX_SIGURG, /* SIGURG */
81 LINUX_SIGSTOP, /* SIGSTOP */
82 LINUX_SIGTSTP, /* SIGTSTP */
83 LINUX_SIGCONT, /* SIGCONT */
84 LINUX_SIGCHLD, /* SIGCHLD */
85 LINUX_SIGTTIN, /* SIGTTIN */
86 LINUX_SIGTTOU, /* SIGTTOU */
87 LINUX_SIGIO, /* SIGIO */
88 LINUX_SIGXCPU, /* SIGXCPU */
89 LINUX_SIGXFSZ, /* SIGXFSZ */
90 LINUX_SIGVTALRM,/* SIGVTALRM */
91 LINUX_SIGPROF, /* SIGPROF */
92 LINUX_SIGWINCH, /* SIGWINCH */
93 0, /* SIGINFO */
94 LINUX_SIGUSR1, /* SIGUSR1 */
95 LINUX_SIGUSR2 /* SIGUSR2 */
96 };
97
98 #define LINUX_SIGPWREMU (SIGRTMIN + (LINUX_SIGRTMAX - LINUX_SIGRTMIN) + 1)
99
100 static int linux_to_bsd_sigtbl[LINUX_SIGTBLSZ] = {
101 SIGHUP, /* LINUX_SIGHUP */
102 SIGINT, /* LINUX_SIGINT */
103 SIGQUIT, /* LINUX_SIGQUIT */
104 SIGILL, /* LINUX_SIGILL */
105 SIGTRAP, /* LINUX_SIGTRAP */
106 SIGABRT, /* LINUX_SIGABRT */
107 SIGBUS, /* LINUX_SIGBUS */
108 SIGFPE, /* LINUX_SIGFPE */
109 SIGKILL, /* LINUX_SIGKILL */
110 SIGUSR1, /* LINUX_SIGUSR1 */
111 SIGSEGV, /* LINUX_SIGSEGV */
112 SIGUSR2, /* LINUX_SIGUSR2 */
113 SIGPIPE, /* LINUX_SIGPIPE */
114 SIGALRM, /* LINUX_SIGALRM */
115 SIGTERM, /* LINUX_SIGTERM */
116 SIGBUS, /* LINUX_SIGSTKFLT */
117 SIGCHLD, /* LINUX_SIGCHLD */
118 SIGCONT, /* LINUX_SIGCONT */
119 SIGSTOP, /* LINUX_SIGSTOP */
120 SIGTSTP, /* LINUX_SIGTSTP */
121 SIGTTIN, /* LINUX_SIGTTIN */
122 SIGTTOU, /* LINUX_SIGTTOU */
123 SIGURG, /* LINUX_SIGURG */
124 SIGXCPU, /* LINUX_SIGXCPU */
125 SIGXFSZ, /* LINUX_SIGXFSZ */
126 SIGVTALRM, /* LINUX_SIGVTALARM */
127 SIGPROF, /* LINUX_SIGPROF */
128 SIGWINCH, /* LINUX_SIGWINCH */
129 SIGIO, /* LINUX_SIGIO */
130 /*
131 * FreeBSD does not have SIGPWR signal, map Linux SIGPWR signal
132 * to the first unused FreeBSD signal number. Since Linux supports
133 * signals from 1 to 64 we are ok here as our SIGRTMIN = 65.
134 */
135 LINUX_SIGPWREMU,/* LINUX_SIGPWR */
136 SIGSYS /* LINUX_SIGSYS */
137 };
138
139 static struct cdev *dev_shm_cdev;
140 static struct cdevsw dev_shm_cdevsw = {
141 .d_version = D_VERSION,
142 .d_name = "dev_shm",
143 };
144
145 /*
146 * Map Linux RT signals to the FreeBSD RT signals.
147 */
148 static inline int
linux_to_bsd_rt_signal(int sig)149 linux_to_bsd_rt_signal(int sig)
150 {
151
152 return (SIGRTMIN + sig - LINUX_SIGRTMIN);
153 }
154
155 static inline int
bsd_to_linux_rt_signal(int sig)156 bsd_to_linux_rt_signal(int sig)
157 {
158
159 return (sig - SIGRTMIN + LINUX_SIGRTMIN);
160 }
161
162 int
linux_to_bsd_signal(int sig)163 linux_to_bsd_signal(int sig)
164 {
165
166 KASSERT(sig > 0 && sig <= LINUX_SIGRTMAX, ("invalid Linux signal %d\n", sig));
167
168 if (sig < LINUX_SIGRTMIN)
169 return (linux_to_bsd_sigtbl[_SIG_IDX(sig)]);
170
171 return (linux_to_bsd_rt_signal(sig));
172 }
173
174 int
bsd_to_linux_signal(int sig)175 bsd_to_linux_signal(int sig)
176 {
177
178 if (sig <= LINUX_SIGTBLSZ)
179 return (bsd_to_linux_sigtbl[_SIG_IDX(sig)]);
180 if (sig == LINUX_SIGPWREMU)
181 return (LINUX_SIGPWR);
182
183 return (bsd_to_linux_rt_signal(sig));
184 }
185
186 int
linux_to_bsd_sigaltstack(int lsa)187 linux_to_bsd_sigaltstack(int lsa)
188 {
189 int bsa = 0;
190
191 if (lsa & LINUX_SS_DISABLE)
192 bsa |= SS_DISABLE;
193 /*
194 * Linux ignores SS_ONSTACK flag for ss
195 * parameter while FreeBSD prohibits it.
196 */
197 return (bsa);
198 }
199
200 int
bsd_to_linux_sigaltstack(int bsa)201 bsd_to_linux_sigaltstack(int bsa)
202 {
203 int lsa = 0;
204
205 if (bsa & SS_DISABLE)
206 lsa |= LINUX_SS_DISABLE;
207 if (bsa & SS_ONSTACK)
208 lsa |= LINUX_SS_ONSTACK;
209 return (lsa);
210 }
211
212 void
linux_to_bsd_sigset(l_sigset_t * lss,sigset_t * bss)213 linux_to_bsd_sigset(l_sigset_t *lss, sigset_t *bss)
214 {
215 int b, l;
216
217 SIGEMPTYSET(*bss);
218 for (l = 1; l <= LINUX_SIGRTMAX; l++) {
219 if (LINUX_SIGISMEMBER(*lss, l)) {
220 b = linux_to_bsd_signal(l);
221 if (b)
222 SIGADDSET(*bss, b);
223 }
224 }
225 }
226
227 void
bsd_to_linux_sigset(sigset_t * bss,l_sigset_t * lss)228 bsd_to_linux_sigset(sigset_t *bss, l_sigset_t *lss)
229 {
230 int b, l;
231
232 LINUX_SIGEMPTYSET(*lss);
233 for (b = 1; b <= SIGRTMAX; b++) {
234 if (SIGISMEMBER(*bss, b)) {
235 l = bsd_to_linux_signal(b);
236 if (l)
237 LINUX_SIGADDSET(*lss, l);
238 }
239 }
240 }
241
242 /*
243 * Translate a FreeBSD interface name to a Linux interface name
244 * by interface name, and return the number of bytes copied to lxname.
245 */
246 int
ifname_bsd_to_linux_name(const char * bsdname,char * lxname,size_t len)247 ifname_bsd_to_linux_name(const char *bsdname, char *lxname, size_t len)
248 {
249 struct epoch_tracker et;
250 struct ifnet *ifp;
251 int ret;
252
253 CURVNET_ASSERT_SET();
254
255 ret = 0;
256 NET_EPOCH_ENTER(et);
257 ifp = ifunit(bsdname);
258 if (ifp != NULL)
259 ret = ifname_bsd_to_linux_ifp(ifp, lxname, len);
260 NET_EPOCH_EXIT(et);
261 return (ret);
262 }
263
264 /*
265 * Translate a FreeBSD interface name to a Linux interface name
266 * by interface index, and return the number of bytes copied to lxname.
267 */
268 int
ifname_bsd_to_linux_idx(u_int idx,char * lxname,size_t len)269 ifname_bsd_to_linux_idx(u_int idx, char *lxname, size_t len)
270 {
271 struct epoch_tracker et;
272 struct ifnet *ifp;
273 int ret;
274
275 ret = 0;
276 CURVNET_SET(TD_TO_VNET(curthread));
277 NET_EPOCH_ENTER(et);
278 ifp = ifnet_byindex(idx);
279 if (ifp != NULL)
280 ret = ifname_bsd_to_linux_ifp(ifp, lxname, len);
281 NET_EPOCH_EXIT(et);
282 CURVNET_RESTORE();
283 return (ret);
284 }
285
286 /*
287 * Translate a FreeBSD interface name to a Linux interface name,
288 * and return the number of bytes copied to lxname.
289 */
290 int
ifname_bsd_to_linux_ifp(struct ifnet * ifp,char * lxname,size_t len)291 ifname_bsd_to_linux_ifp(struct ifnet *ifp, char *lxname, size_t len)
292 {
293 struct ifnet *ifscan;
294 int unit;
295
296 NET_EPOCH_ASSERT();
297
298 /*
299 * Linux loopback interface name is lo (not lo0),
300 * we translate lo to lo0, loX to loX.
301 */
302 if (IFP_IS_LOOP(ifp) && strncmp(ifp->if_xname, "lo0", IFNAMSIZ) == 0)
303 return (strlcpy(lxname, "lo", len));
304
305 /* Short-circuit non ethernet interfaces. */
306 if (!IFP_IS_ETH(ifp) || linux_use_real_ifname(ifp))
307 return (strlcpy(lxname, ifp->if_xname, len));
308
309 /* Determine the (relative) unit number for ethernet interfaces. */
310 unit = 0;
311 CK_STAILQ_FOREACH(ifscan, &V_ifnet, if_link) {
312 if (ifscan == ifp)
313 return (snprintf(lxname, len, "eth%d", unit));
314 if (IFP_IS_ETH(ifscan))
315 unit++;
316 }
317 return (0);
318 }
319
320 /*
321 * Translate a Linux interface name to a FreeBSD interface name,
322 * and return the associated ifnet structure
323 * bsdname and lxname need to be least IFNAMSIZ bytes long, but
324 * can point to the same buffer.
325 */
326 struct ifnet *
ifname_linux_to_bsd(struct thread * td,const char * lxname,char * bsdname)327 ifname_linux_to_bsd(struct thread *td, const char *lxname, char *bsdname)
328 {
329 struct ifnet *ifp;
330 int len, unit;
331 char *ep;
332 int index;
333 bool is_eth, is_lo;
334
335 for (len = 0; len < LINUX_IFNAMSIZ; ++len)
336 if (!isalpha(lxname[len]) || lxname[len] == '\0')
337 break;
338 if (len == 0 || len == LINUX_IFNAMSIZ)
339 return (NULL);
340 /*
341 * Linux loopback interface name is lo (not lo0),
342 * we translate lo to lo0, loX to loX.
343 */
344 is_lo = (len == 2 && strncmp(lxname, "lo", LINUX_IFNAMSIZ) == 0);
345 unit = (int)strtoul(lxname + len, &ep, 10);
346 if ((ep == NULL || ep == lxname + len || ep >= lxname + LINUX_IFNAMSIZ) &&
347 is_lo == 0)
348 return (NULL);
349 index = 0;
350 is_eth = (len == 3 && strncmp(lxname, "eth", len) == 0);
351
352 CURVNET_SET(TD_TO_VNET(td));
353 IFNET_RLOCK();
354 CK_STAILQ_FOREACH(ifp, &V_ifnet, if_link) {
355 /*
356 * Allow Linux programs to use FreeBSD names. Don't presume
357 * we never have an interface named "eth", so don't make
358 * the test optional based on is_eth.
359 */
360 if (strncmp(ifp->if_xname, lxname, LINUX_IFNAMSIZ) == 0)
361 break;
362 if (is_eth && IFP_IS_ETH(ifp) && unit == index++)
363 break;
364 if (is_lo && IFP_IS_LOOP(ifp))
365 break;
366 }
367 IFNET_RUNLOCK();
368 CURVNET_RESTORE();
369 if (ifp != NULL && bsdname != NULL)
370 strlcpy(bsdname, ifp->if_xname, IFNAMSIZ);
371 return (ifp);
372 }
373
374 void
linux_ifflags(struct ifnet * ifp,short * flags)375 linux_ifflags(struct ifnet *ifp, short *flags)
376 {
377 unsigned short fl;
378
379 fl = (ifp->if_flags | ifp->if_drv_flags) & 0xffff;
380 *flags = 0;
381 if (fl & IFF_UP)
382 *flags |= LINUX_IFF_UP;
383 if (fl & IFF_BROADCAST)
384 *flags |= LINUX_IFF_BROADCAST;
385 if (fl & IFF_DEBUG)
386 *flags |= LINUX_IFF_DEBUG;
387 if (fl & IFF_LOOPBACK)
388 *flags |= LINUX_IFF_LOOPBACK;
389 if (fl & IFF_POINTOPOINT)
390 *flags |= LINUX_IFF_POINTOPOINT;
391 if (fl & IFF_DRV_RUNNING)
392 *flags |= LINUX_IFF_RUNNING;
393 if (fl & IFF_NOARP)
394 *flags |= LINUX_IFF_NOARP;
395 if (fl & IFF_PROMISC)
396 *flags |= LINUX_IFF_PROMISC;
397 if (fl & IFF_ALLMULTI)
398 *flags |= LINUX_IFF_ALLMULTI;
399 if (fl & IFF_MULTICAST)
400 *flags |= LINUX_IFF_MULTICAST;
401 }
402
403 int
linux_ifhwaddr(struct ifnet * ifp,struct l_sockaddr * lsa)404 linux_ifhwaddr(struct ifnet *ifp, struct l_sockaddr *lsa)
405 {
406 struct ifaddr *ifa;
407 struct sockaddr_dl *sdl;
408
409 if (IFP_IS_LOOP(ifp)) {
410 bzero(lsa, sizeof(*lsa));
411 lsa->sa_family = LINUX_ARPHRD_LOOPBACK;
412 return (0);
413 }
414
415 if (!IFP_IS_ETH(ifp))
416 return (ENOENT);
417
418 CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
419 sdl = (struct sockaddr_dl*)ifa->ifa_addr;
420 if (sdl != NULL && (sdl->sdl_family == AF_LINK) &&
421 (sdl->sdl_type == IFT_ETHER)) {
422 bzero(lsa, sizeof(*lsa));
423 lsa->sa_family = LINUX_ARPHRD_ETHER;
424 bcopy(LLADDR(sdl), lsa->sa_data, LINUX_IFHWADDRLEN);
425 return (0);
426 }
427 }
428
429 return (ENOENT);
430 }
431
432 int
linux_to_bsd_domain(int domain)433 linux_to_bsd_domain(int domain)
434 {
435
436 switch (domain) {
437 case LINUX_AF_UNSPEC:
438 return (AF_UNSPEC);
439 case LINUX_AF_UNIX:
440 return (AF_LOCAL);
441 case LINUX_AF_INET:
442 return (AF_INET);
443 case LINUX_AF_INET6:
444 return (AF_INET6);
445 case LINUX_AF_AX25:
446 return (AF_CCITT);
447 case LINUX_AF_IPX:
448 return (AF_IPX);
449 case LINUX_AF_APPLETALK:
450 return (AF_APPLETALK);
451 case LINUX_AF_NETLINK:
452 return (AF_NETLINK);
453 }
454 return (-1);
455 }
456
457 int
bsd_to_linux_domain(int domain)458 bsd_to_linux_domain(int domain)
459 {
460
461 switch (domain) {
462 case AF_UNSPEC:
463 return (LINUX_AF_UNSPEC);
464 case AF_LOCAL:
465 return (LINUX_AF_UNIX);
466 case AF_INET:
467 return (LINUX_AF_INET);
468 case AF_INET6:
469 return (LINUX_AF_INET6);
470 case AF_CCITT:
471 return (LINUX_AF_AX25);
472 case AF_IPX:
473 return (LINUX_AF_IPX);
474 case AF_APPLETALK:
475 return (LINUX_AF_APPLETALK);
476 case AF_NETLINK:
477 return (LINUX_AF_NETLINK);
478 }
479 return (-1);
480 }
481
482 /*
483 * Based on the fact that:
484 * 1. Native and Linux storage of struct sockaddr
485 * and struct sockaddr_in6 are equal.
486 * 2. On Linux sa_family is the first member of all struct sockaddr.
487 */
488 int
bsd_to_linux_sockaddr(const struct sockaddr * sa,struct l_sockaddr ** lsa,socklen_t len)489 bsd_to_linux_sockaddr(const struct sockaddr *sa, struct l_sockaddr **lsa,
490 socklen_t len)
491 {
492 struct l_sockaddr *kosa;
493 int bdom;
494
495 *lsa = NULL;
496 if (len < 2 || len > UCHAR_MAX)
497 return (EINVAL);
498 bdom = bsd_to_linux_domain(sa->sa_family);
499 if (bdom == -1)
500 return (EAFNOSUPPORT);
501
502 kosa = malloc(len, M_LINUX, M_WAITOK);
503 bcopy(sa, kosa, len);
504 kosa->sa_family = bdom;
505 *lsa = kosa;
506 return (0);
507 }
508
509 int
linux_to_bsd_sockaddr(const struct l_sockaddr * osa,struct sockaddr ** sap,socklen_t * len)510 linux_to_bsd_sockaddr(const struct l_sockaddr *osa, struct sockaddr **sap,
511 socklen_t *len)
512 {
513 struct sockaddr *sa;
514 struct l_sockaddr *kosa;
515 #ifdef INET6
516 struct sockaddr_in6 *sin6;
517 bool oldv6size;
518 #endif
519 char *name;
520 int salen, bdom, error, hdrlen, namelen;
521
522 if (*len < 2 || *len > UCHAR_MAX)
523 return (EINVAL);
524
525 salen = *len;
526
527 #ifdef INET6
528 oldv6size = false;
529 /*
530 * Check for old (pre-RFC2553) sockaddr_in6. We may accept it
531 * if it's a v4-mapped address, so reserve the proper space
532 * for it.
533 */
534 if (salen == sizeof(struct sockaddr_in6) - sizeof(uint32_t)) {
535 salen += sizeof(uint32_t);
536 oldv6size = true;
537 }
538 #endif
539
540 kosa = malloc(salen, M_SONAME, M_WAITOK);
541
542 if ((error = copyin(osa, kosa, *len)))
543 goto out;
544
545 bdom = linux_to_bsd_domain(kosa->sa_family);
546 if (bdom == -1) {
547 error = EAFNOSUPPORT;
548 goto out;
549 }
550
551 #ifdef INET6
552 /*
553 * Older Linux IPv6 code uses obsolete RFC2133 struct sockaddr_in6,
554 * which lacks the scope id compared with RFC2553 one. If we detect
555 * the situation, reject the address and write a message to system log.
556 *
557 * Still accept addresses for which the scope id is not used.
558 */
559 if (oldv6size) {
560 if (bdom == AF_INET6) {
561 sin6 = (struct sockaddr_in6 *)kosa;
562 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr) ||
563 (!IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr) &&
564 !IN6_IS_ADDR_SITELOCAL(&sin6->sin6_addr) &&
565 !IN6_IS_ADDR_V4COMPAT(&sin6->sin6_addr) &&
566 !IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr) &&
567 !IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr))) {
568 sin6->sin6_scope_id = 0;
569 } else {
570 linux_msg(curthread,
571 "obsolete pre-RFC2553 sockaddr_in6 rejected");
572 error = EINVAL;
573 goto out;
574 }
575 } else
576 salen -= sizeof(uint32_t);
577 }
578 #endif
579 if (bdom == AF_INET) {
580 if (salen < sizeof(struct sockaddr_in)) {
581 error = EINVAL;
582 goto out;
583 }
584 salen = sizeof(struct sockaddr_in);
585 }
586
587 if (bdom == AF_LOCAL && salen > sizeof(struct sockaddr_un)) {
588 hdrlen = offsetof(struct sockaddr_un, sun_path);
589 name = ((struct sockaddr_un *)kosa)->sun_path;
590 if (*name == '\0') {
591 /*
592 * Linux abstract namespace starts with a NULL byte.
593 * XXX We do not support abstract namespace yet.
594 */
595 namelen = strnlen(name + 1, salen - hdrlen - 1) + 1;
596 } else
597 namelen = strnlen(name, salen - hdrlen);
598 salen = hdrlen + namelen;
599 if (salen > sizeof(struct sockaddr_un)) {
600 error = ENAMETOOLONG;
601 goto out;
602 }
603 }
604
605 if (bdom == AF_NETLINK) {
606 if (salen < sizeof(struct sockaddr_nl)) {
607 error = EINVAL;
608 goto out;
609 }
610 salen = sizeof(struct sockaddr_nl);
611 }
612
613 sa = (struct sockaddr *)kosa;
614 sa->sa_family = bdom;
615 sa->sa_len = salen;
616
617 *sap = sa;
618 *len = salen;
619 return (0);
620
621 out:
622 free(kosa, M_SONAME);
623 return (error);
624 }
625
626 void
linux_dev_shm_create(void)627 linux_dev_shm_create(void)
628 {
629 int error;
630
631 error = make_dev_p(MAKEDEV_CHECKNAME | MAKEDEV_WAITOK, &dev_shm_cdev,
632 &dev_shm_cdevsw, NULL, UID_ROOT, GID_WHEEL, 0, "shm/.mountpoint");
633 if (error != 0) {
634 printf("%s: failed to create device node, error %d\n",
635 __func__, error);
636 }
637 }
638
639 void
linux_dev_shm_destroy(void)640 linux_dev_shm_destroy(void)
641 {
642
643 destroy_dev(dev_shm_cdev);
644 }
645
646 int
bsd_to_linux_bits_(int value,struct bsd_to_linux_bitmap * bitmap,size_t mapcnt,int no_value)647 bsd_to_linux_bits_(int value, struct bsd_to_linux_bitmap *bitmap,
648 size_t mapcnt, int no_value)
649 {
650 int bsd_mask, bsd_value, linux_mask, linux_value;
651 int linux_ret;
652 size_t i;
653 bool applied;
654
655 applied = false;
656 linux_ret = 0;
657 for (i = 0; i < mapcnt; ++i) {
658 bsd_mask = bitmap[i].bsd_mask;
659 bsd_value = bitmap[i].bsd_value;
660 if (bsd_mask == 0)
661 bsd_mask = bsd_value;
662
663 linux_mask = bitmap[i].linux_mask;
664 linux_value = bitmap[i].linux_value;
665 if (linux_mask == 0)
666 linux_mask = linux_value;
667
668 /*
669 * If a mask larger than just the value is set, we explicitly
670 * want to make sure that only this bit we mapped within that
671 * mask is set.
672 */
673 if ((value & bsd_mask) == bsd_value) {
674 linux_ret = (linux_ret & ~linux_mask) | linux_value;
675 applied = true;
676 }
677 }
678
679 if (!applied)
680 return (no_value);
681 return (linux_ret);
682 }
683
684 int
linux_to_bsd_bits_(int value,struct bsd_to_linux_bitmap * bitmap,size_t mapcnt,int no_value)685 linux_to_bsd_bits_(int value, struct bsd_to_linux_bitmap *bitmap,
686 size_t mapcnt, int no_value)
687 {
688 int bsd_mask, bsd_value, linux_mask, linux_value;
689 int bsd_ret;
690 size_t i;
691 bool applied;
692
693 applied = false;
694 bsd_ret = 0;
695 for (i = 0; i < mapcnt; ++i) {
696 bsd_mask = bitmap[i].bsd_mask;
697 bsd_value = bitmap[i].bsd_value;
698 if (bsd_mask == 0)
699 bsd_mask = bsd_value;
700
701 linux_mask = bitmap[i].linux_mask;
702 linux_value = bitmap[i].linux_value;
703 if (linux_mask == 0)
704 linux_mask = linux_value;
705
706 /*
707 * If a mask larger than just the value is set, we explicitly
708 * want to make sure that only this bit we mapped within that
709 * mask is set.
710 */
711 if ((value & linux_mask) == linux_value) {
712 bsd_ret = (bsd_ret & ~bsd_mask) | bsd_value;
713 applied = true;
714 }
715 }
716
717 if (!applied)
718 return (no_value);
719 return (bsd_ret);
720 }
721
722 void
linux_to_bsd_poll_events(struct thread * td,int fd,short lev,short * bev)723 linux_to_bsd_poll_events(struct thread *td, int fd, short lev,
724 short *bev)
725 {
726 struct proc *p = td->td_proc;
727 struct filedesc *fdp;
728 struct file *fp;
729 int error;
730 short bits = 0;
731
732 if (lev & LINUX_POLLIN)
733 bits |= POLLIN;
734 if (lev & LINUX_POLLPRI)
735 bits |= POLLPRI;
736 if (lev & LINUX_POLLOUT)
737 bits |= POLLOUT;
738 if (lev & LINUX_POLLERR)
739 bits |= POLLERR;
740 if (lev & LINUX_POLLHUP)
741 bits |= POLLHUP;
742 if (lev & LINUX_POLLNVAL)
743 bits |= POLLNVAL;
744 if (lev & LINUX_POLLRDNORM)
745 bits |= POLLRDNORM;
746 if (lev & LINUX_POLLRDBAND)
747 bits |= POLLRDBAND;
748 if (lev & LINUX_POLLWRBAND)
749 bits |= POLLWRBAND;
750 if (lev & LINUX_POLLWRNORM)
751 bits |= POLLWRNORM;
752
753 if (lev & LINUX_POLLRDHUP) {
754 /*
755 * It seems that the Linux silencly ignores POLLRDHUP
756 * on non-socket file descriptors unlike FreeBSD, where
757 * events bits is more strictly checked (POLLSTANDARD).
758 */
759 fdp = p->p_fd;
760 error = fget_unlocked(fdp, fd, &cap_no_rights, &fp);
761 if (error == 0) {
762 /*
763 * XXX. On FreeBSD POLLRDHUP applies only to
764 * stream sockets.
765 */
766 if (fp->f_type == DTYPE_SOCKET)
767 bits |= POLLRDHUP;
768 fdrop(fp, td);
769 }
770 }
771
772 if (lev & LINUX_POLLMSG)
773 LINUX_RATELIMIT_MSG_OPT1("unsupported POLLMSG, events(%d)", lev);
774 if (lev & LINUX_POLLREMOVE)
775 LINUX_RATELIMIT_MSG_OPT1("unsupported POLLREMOVE, events(%d)", lev);
776
777 *bev = bits;
778 }
779
780 void
bsd_to_linux_poll_events(short bev,short * lev)781 bsd_to_linux_poll_events(short bev, short *lev)
782 {
783 short bits = 0;
784
785 if (bev & POLLIN)
786 bits |= LINUX_POLLIN;
787 if (bev & POLLPRI)
788 bits |= LINUX_POLLPRI;
789 if (bev & (POLLOUT | POLLWRNORM))
790 /*
791 * POLLWRNORM is equal to POLLOUT on FreeBSD,
792 * but not on Linux
793 */
794 bits |= LINUX_POLLOUT;
795 if (bev & POLLERR)
796 bits |= LINUX_POLLERR;
797 if (bev & POLLHUP)
798 bits |= LINUX_POLLHUP;
799 if (bev & POLLNVAL)
800 bits |= LINUX_POLLNVAL;
801 if (bev & POLLRDNORM)
802 bits |= LINUX_POLLRDNORM;
803 if (bev & POLLRDBAND)
804 bits |= LINUX_POLLRDBAND;
805 if (bev & POLLWRBAND)
806 bits |= LINUX_POLLWRBAND;
807 if (bev & POLLRDHUP)
808 bits |= LINUX_POLLRDHUP;
809
810 *lev = bits;
811 }
812
813 bool
linux_use_real_ifname(const struct ifnet * ifp)814 linux_use_real_ifname(const struct ifnet *ifp)
815 {
816
817 return (use_real_ifnames);
818 }
819