Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
4 */
5
6#include <stdio.h>
7#include <unistd.h>
8#include <stdarg.h>
9#include <errno.h>
10#include <stddef.h>
11#include <string.h>
12#include <sys/ioctl.h>
13#include <net/if.h>
14#include <linux/if_tun.h>
15#include <arpa/inet.h>
16#include <sys/types.h>
17#include <sys/stat.h>
18#include <fcntl.h>
19#include <sys/socket.h>
20#include <sys/un.h>
21#include <net/ethernet.h>
22#include <netinet/ip.h>
23#include <netinet/ether.h>
24#include <linux/if_ether.h>
25#include <linux/if_packet.h>
26#include <sys/wait.h>
27#include <sys/uio.h>
28#include <linux/virtio_net.h>
29#include <netdb.h>
30#include <stdlib.h>
31#include <os.h>
32#include <um_malloc.h>
33#include "vector_user.h"
34
35#define ID_GRE 0
36#define ID_L2TPV3 1
37#define ID_BESS 2
38#define ID_MAX 2
39
40#define TOKEN_IFNAME "ifname"
41
42#define TRANS_RAW "raw"
43#define TRANS_RAW_LEN strlen(TRANS_RAW)
44
45#define VNET_HDR_FAIL "could not enable vnet headers on fd %d"
46#define TUN_GET_F_FAIL "tapraw: TUNGETFEATURES failed: %s"
47#define L2TPV3_BIND_FAIL "l2tpv3_open : could not bind socket err=%i"
48#define UNIX_BIND_FAIL "unix_open : could not bind socket err=%i"
49#define BPF_ATTACH_FAIL "Failed to attach filter size %d prog %px to %d, err %d\n"
50#define BPF_DETACH_FAIL "Failed to detach filter size %d prog %px to %d, err %d\n"
51
52#define MAX_UN_LEN 107
53
54/* This is very ugly and brute force lookup, but it is done
55 * only once at initialization so not worth doing hashes or
56 * anything more intelligent
57 */
58
59char *uml_vector_fetch_arg(struct arglist *ifspec, char *token)
60{
61 int i;
62
63 for (i = 0; i < ifspec->numargs; i++) {
64 if (strcmp(ifspec->tokens[i], token) == 0)
65 return ifspec->values[i];
66 }
67 return NULL;
68
69}
70
71struct arglist *uml_parse_vector_ifspec(char *arg)
72{
73 struct arglist *result;
74 int pos, len;
75 bool parsing_token = true, next_starts = true;
76
77 if (arg == NULL)
78 return NULL;
79 result = uml_kmalloc(sizeof(struct arglist), UM_GFP_KERNEL);
80 if (result == NULL)
81 return NULL;
82 result->numargs = 0;
83 len = strlen(arg);
84 for (pos = 0; pos < len; pos++) {
85 if (next_starts) {
86 if (parsing_token) {
87 result->tokens[result->numargs] = arg + pos;
88 } else {
89 result->values[result->numargs] = arg + pos;
90 result->numargs++;
91 }
92 next_starts = false;
93 }
94 if (*(arg + pos) == '=') {
95 if (parsing_token)
96 parsing_token = false;
97 else
98 goto cleanup;
99 next_starts = true;
100 (*(arg + pos)) = '\0';
101 }
102 if (*(arg + pos) == ',') {
103 parsing_token = true;
104 next_starts = true;
105 (*(arg + pos)) = '\0';
106 }
107 }
108 return result;
109cleanup:
110 printk(UM_KERN_ERR "vector_setup - Couldn't parse '%s'\n", arg);
111 kfree(result);
112 return NULL;
113}
114
115/*
116 * Socket/FD configuration functions. These return an structure
117 * of rx and tx descriptors to cover cases where these are not
118 * the same (f.e. read via raw socket and write via tap).
119 */
120
121#define PATH_NET_TUN "/dev/net/tun"
122
123
124static int create_tap_fd(char *iface)
125{
126 struct ifreq ifr;
127 int fd = -1;
128 int err = -ENOMEM, offload;
129
130 fd = open(PATH_NET_TUN, O_RDWR);
131 if (fd < 0) {
132 printk(UM_KERN_ERR "uml_tap: failed to open tun device\n");
133 goto tap_fd_cleanup;
134 }
135 memset(&ifr, 0, sizeof(ifr));
136 ifr.ifr_flags = IFF_TAP | IFF_NO_PI | IFF_VNET_HDR;
137 strncpy((char *)&ifr.ifr_name, iface, sizeof(ifr.ifr_name) - 1);
138
139 err = ioctl(fd, TUNSETIFF, (void *) &ifr);
140 if (err != 0) {
141 printk(UM_KERN_ERR "uml_tap: failed to select tap interface\n");
142 goto tap_fd_cleanup;
143 }
144
145 offload = TUN_F_CSUM | TUN_F_TSO4 | TUN_F_TSO6;
146 ioctl(fd, TUNSETOFFLOAD, offload);
147 return fd;
148tap_fd_cleanup:
149 if (fd >= 0)
150 os_close_file(fd);
151 return err;
152}
153
154static int create_raw_fd(char *iface, int flags, int proto)
155{
156 struct ifreq ifr;
157 int fd = -1;
158 struct sockaddr_ll sock;
159 int err = -ENOMEM;
160
161 fd = socket(AF_PACKET, SOCK_RAW, flags);
162 if (fd == -1) {
163 err = -errno;
164 goto raw_fd_cleanup;
165 }
166 memset(&ifr, 0, sizeof(ifr));
167 strncpy((char *)&ifr.ifr_name, iface, sizeof(ifr.ifr_name) - 1);
168 if (ioctl(fd, SIOCGIFINDEX, (void *) &ifr) < 0) {
169 err = -errno;
170 goto raw_fd_cleanup;
171 }
172
173 sock.sll_family = AF_PACKET;
174 sock.sll_protocol = htons(proto);
175 sock.sll_ifindex = ifr.ifr_ifindex;
176
177 if (bind(fd,
178 (struct sockaddr *) &sock, sizeof(struct sockaddr_ll)) < 0) {
179 err = -errno;
180 goto raw_fd_cleanup;
181 }
182 return fd;
183raw_fd_cleanup:
184 printk(UM_KERN_ERR "user_init_raw: init failed, error %d", err);
185 if (fd >= 0)
186 os_close_file(fd);
187 return err;
188}
189
190static struct vector_fds *user_init_tap_fds(struct arglist *ifspec)
191{
192 int fd = -1;
193 char *iface;
194 struct vector_fds *result = NULL;
195
196 iface = uml_vector_fetch_arg(ifspec, TOKEN_IFNAME);
197 if (iface == NULL) {
198 printk(UM_KERN_ERR "uml_tap: failed to parse interface spec\n");
199 goto tap_cleanup;
200 }
201
202 result = uml_kmalloc(sizeof(struct vector_fds), UM_GFP_KERNEL);
203 if (result == NULL) {
204 printk(UM_KERN_ERR "uml_tap: failed to allocate file descriptors\n");
205 goto tap_cleanup;
206 }
207 result->rx_fd = -1;
208 result->tx_fd = -1;
209 result->remote_addr = NULL;
210 result->remote_addr_size = 0;
211
212 /* TAP */
213
214 fd = create_tap_fd(iface);
215 if (fd < 0) {
216 printk(UM_KERN_ERR "uml_tap: failed to create tun interface\n");
217 goto tap_cleanup;
218 }
219 result->tx_fd = fd;
220 result->rx_fd = fd;
221 return result;
222tap_cleanup:
223 printk(UM_KERN_ERR "user_init_tap: init failed, error %d", fd);
224 if (result != NULL)
225 kfree(result);
226 return NULL;
227}
228
229static struct vector_fds *user_init_hybrid_fds(struct arglist *ifspec)
230{
231 char *iface;
232 struct vector_fds *result = NULL;
233
234 iface = uml_vector_fetch_arg(ifspec, TOKEN_IFNAME);
235 if (iface == NULL) {
236 printk(UM_KERN_ERR "uml_tap: failed to parse interface spec\n");
237 goto hybrid_cleanup;
238 }
239
240 result = uml_kmalloc(sizeof(struct vector_fds), UM_GFP_KERNEL);
241 if (result == NULL) {
242 printk(UM_KERN_ERR "uml_tap: failed to allocate file descriptors\n");
243 goto hybrid_cleanup;
244 }
245 result->rx_fd = -1;
246 result->tx_fd = -1;
247 result->remote_addr = NULL;
248 result->remote_addr_size = 0;
249
250 /* TAP */
251
252 result->tx_fd = create_tap_fd(iface);
253 if (result->tx_fd < 0) {
254 printk(UM_KERN_ERR "uml_tap: failed to create tun interface: %i\n", result->tx_fd);
255 goto hybrid_cleanup;
256 }
257
258 /* RAW */
259
260 result->rx_fd = create_raw_fd(iface, ETH_P_ALL, ETH_P_ALL);
261 if (result->rx_fd == -1) {
262 printk(UM_KERN_ERR
263 "uml_tap: failed to create paired raw socket: %i\n", result->rx_fd);
264 goto hybrid_cleanup;
265 }
266 return result;
267hybrid_cleanup:
268 printk(UM_KERN_ERR "user_init_hybrid: init failed");
269 if (result != NULL)
270 kfree(result);
271 return NULL;
272}
273
274static struct vector_fds *user_init_unix_fds(struct arglist *ifspec, int id)
275{
276 int fd = -1;
277 int socktype;
278 char *src, *dst;
279 struct vector_fds *result = NULL;
280 struct sockaddr_un *local_addr = NULL, *remote_addr = NULL;
281
282 src = uml_vector_fetch_arg(ifspec, "src");
283 dst = uml_vector_fetch_arg(ifspec, "dst");
284 result = uml_kmalloc(sizeof(struct vector_fds), UM_GFP_KERNEL);
285 if (result == NULL) {
286 printk(UM_KERN_ERR "unix open:cannot allocate remote addr");
287 goto unix_cleanup;
288 }
289 remote_addr = uml_kmalloc(sizeof(struct sockaddr_un), UM_GFP_KERNEL);
290 if (remote_addr == NULL) {
291 printk(UM_KERN_ERR "unix open:cannot allocate remote addr");
292 goto unix_cleanup;
293 }
294
295 switch (id) {
296 case ID_BESS:
297 socktype = SOCK_SEQPACKET;
298 if ((src != NULL) && (strlen(src) <= MAX_UN_LEN)) {
299 local_addr = uml_kmalloc(sizeof(struct sockaddr_un), UM_GFP_KERNEL);
300 if (local_addr == NULL) {
301 printk(UM_KERN_ERR "bess open:cannot allocate local addr");
302 goto unix_cleanup;
303 }
304 local_addr->sun_family = AF_UNIX;
305 memcpy(local_addr->sun_path, src, strlen(src) + 1);
306 }
307 if ((dst == NULL) || (strlen(dst) > MAX_UN_LEN))
308 goto unix_cleanup;
309 remote_addr->sun_family = AF_UNIX;
310 memcpy(remote_addr->sun_path, dst, strlen(dst) + 1);
311 break;
312 default:
313 printk(KERN_ERR "Unsupported unix socket type\n");
314 return NULL;
315 }
316
317 fd = socket(AF_UNIX, socktype, 0);
318 if (fd == -1) {
319 printk(UM_KERN_ERR
320 "unix open: could not open socket, error = %d",
321 -errno
322 );
323 goto unix_cleanup;
324 }
325 if (local_addr != NULL) {
326 if (bind(fd, (struct sockaddr *) local_addr, sizeof(struct sockaddr_un))) {
327 printk(UM_KERN_ERR UNIX_BIND_FAIL, errno);
328 goto unix_cleanup;
329 }
330 }
331 switch (id) {
332 case ID_BESS:
333 if (connect(fd, remote_addr, sizeof(struct sockaddr_un)) < 0) {
334 printk(UM_KERN_ERR "bess open:cannot connect to %s %i", remote_addr->sun_path, -errno);
335 goto unix_cleanup;
336 }
337 break;
338 }
339 result->rx_fd = fd;
340 result->tx_fd = fd;
341 result->remote_addr_size = sizeof(struct sockaddr_un);
342 result->remote_addr = remote_addr;
343 return result;
344unix_cleanup:
345 if (fd >= 0)
346 os_close_file(fd);
347 if (remote_addr != NULL)
348 kfree(remote_addr);
349 if (result != NULL)
350 kfree(result);
351 return NULL;
352}
353
354static struct vector_fds *user_init_raw_fds(struct arglist *ifspec)
355{
356 int rxfd = -1, txfd = -1;
357 int err = -ENOMEM;
358 char *iface;
359 struct vector_fds *result = NULL;
360
361 iface = uml_vector_fetch_arg(ifspec, TOKEN_IFNAME);
362 if (iface == NULL)
363 goto raw_cleanup;
364
365 rxfd = create_raw_fd(iface, ETH_P_ALL, ETH_P_ALL);
366 if (rxfd == -1) {
367 err = -errno;
368 goto raw_cleanup;
369 }
370 txfd = create_raw_fd(iface, 0, ETH_P_IP); /* Turn off RX on this fd */
371 if (txfd == -1) {
372 err = -errno;
373 goto raw_cleanup;
374 }
375 result = uml_kmalloc(sizeof(struct vector_fds), UM_GFP_KERNEL);
376 if (result != NULL) {
377 result->rx_fd = rxfd;
378 result->tx_fd = txfd;
379 result->remote_addr = NULL;
380 result->remote_addr_size = 0;
381 }
382 return result;
383raw_cleanup:
384 printk(UM_KERN_ERR "user_init_raw: init failed, error %d", err);
385 if (result != NULL)
386 kfree(result);
387 return NULL;
388}
389
390
391bool uml_raw_enable_qdisc_bypass(int fd)
392{
393 int optval = 1;
394
395 if (setsockopt(fd,
396 SOL_PACKET, PACKET_QDISC_BYPASS,
397 &optval, sizeof(optval)) != 0) {
398 return false;
399 }
400 return true;
401}
402
403bool uml_raw_enable_vnet_headers(int fd)
404{
405 int optval = 1;
406
407 if (setsockopt(fd,
408 SOL_PACKET, PACKET_VNET_HDR,
409 &optval, sizeof(optval)) != 0) {
410 printk(UM_KERN_INFO VNET_HDR_FAIL, fd);
411 return false;
412 }
413 return true;
414}
415bool uml_tap_enable_vnet_headers(int fd)
416{
417 unsigned int features;
418 int len = sizeof(struct virtio_net_hdr);
419
420 if (ioctl(fd, TUNGETFEATURES, &features) == -1) {
421 printk(UM_KERN_INFO TUN_GET_F_FAIL, strerror(errno));
422 return false;
423 }
424 if ((features & IFF_VNET_HDR) == 0) {
425 printk(UM_KERN_INFO "tapraw: No VNET HEADER support");
426 return false;
427 }
428 ioctl(fd, TUNSETVNETHDRSZ, &len);
429 return true;
430}
431
432static struct vector_fds *user_init_socket_fds(struct arglist *ifspec, int id)
433{
434 int err = -ENOMEM;
435 int fd = -1, gairet;
436 struct addrinfo srchints;
437 struct addrinfo dsthints;
438 bool v6, udp;
439 char *value;
440 char *src, *dst, *srcport, *dstport;
441 struct addrinfo *gairesult = NULL;
442 struct vector_fds *result = NULL;
443
444
445 value = uml_vector_fetch_arg(ifspec, "v6");
446 v6 = false;
447 udp = false;
448 if (value != NULL) {
449 if (strtol((const char *) value, NULL, 10) > 0)
450 v6 = true;
451 }
452
453 value = uml_vector_fetch_arg(ifspec, "udp");
454 if (value != NULL) {
455 if (strtol((const char *) value, NULL, 10) > 0)
456 udp = true;
457 }
458 src = uml_vector_fetch_arg(ifspec, "src");
459 dst = uml_vector_fetch_arg(ifspec, "dst");
460 srcport = uml_vector_fetch_arg(ifspec, "srcport");
461 dstport = uml_vector_fetch_arg(ifspec, "dstport");
462
463 memset(&dsthints, 0, sizeof(dsthints));
464
465 if (v6)
466 dsthints.ai_family = AF_INET6;
467 else
468 dsthints.ai_family = AF_INET;
469
470 switch (id) {
471 case ID_GRE:
472 dsthints.ai_socktype = SOCK_RAW;
473 dsthints.ai_protocol = IPPROTO_GRE;
474 break;
475 case ID_L2TPV3:
476 if (udp) {
477 dsthints.ai_socktype = SOCK_DGRAM;
478 dsthints.ai_protocol = 0;
479 } else {
480 dsthints.ai_socktype = SOCK_RAW;
481 dsthints.ai_protocol = IPPROTO_L2TP;
482 }
483 break;
484 default:
485 printk(KERN_ERR "Unsupported socket type\n");
486 return NULL;
487 }
488 memcpy(&srchints, &dsthints, sizeof(struct addrinfo));
489
490 gairet = getaddrinfo(src, srcport, &dsthints, &gairesult);
491 if ((gairet != 0) || (gairesult == NULL)) {
492 printk(UM_KERN_ERR
493 "socket_open : could not resolve src, error = %s",
494 gai_strerror(gairet)
495 );
496 return NULL;
497 }
498 fd = socket(gairesult->ai_family,
499 gairesult->ai_socktype, gairesult->ai_protocol);
500 if (fd == -1) {
501 printk(UM_KERN_ERR
502 "socket_open : could not open socket, error = %d",
503 -errno
504 );
505 goto cleanup;
506 }
507 if (bind(fd,
508 (struct sockaddr *) gairesult->ai_addr,
509 gairesult->ai_addrlen)) {
510 printk(UM_KERN_ERR L2TPV3_BIND_FAIL, errno);
511 goto cleanup;
512 }
513
514 if (gairesult != NULL)
515 freeaddrinfo(gairesult);
516
517 gairesult = NULL;
518
519 gairet = getaddrinfo(dst, dstport, &dsthints, &gairesult);
520 if ((gairet != 0) || (gairesult == NULL)) {
521 printk(UM_KERN_ERR
522 "socket_open : could not resolve dst, error = %s",
523 gai_strerror(gairet)
524 );
525 return NULL;
526 }
527
528 result = uml_kmalloc(sizeof(struct vector_fds), UM_GFP_KERNEL);
529 if (result != NULL) {
530 result->rx_fd = fd;
531 result->tx_fd = fd;
532 result->remote_addr = uml_kmalloc(
533 gairesult->ai_addrlen, UM_GFP_KERNEL);
534 if (result->remote_addr == NULL)
535 goto cleanup;
536 result->remote_addr_size = gairesult->ai_addrlen;
537 memcpy(
538 result->remote_addr,
539 gairesult->ai_addr,
540 gairesult->ai_addrlen
541 );
542 }
543 freeaddrinfo(gairesult);
544 return result;
545cleanup:
546 if (gairesult != NULL)
547 freeaddrinfo(gairesult);
548 printk(UM_KERN_ERR "user_init_socket: init failed, error %d", err);
549 if (fd >= 0)
550 os_close_file(fd);
551 if (result != NULL) {
552 kfree(result->remote_addr);
553 kfree(result);
554 }
555 return NULL;
556}
557
558struct vector_fds *uml_vector_user_open(
559 int unit,
560 struct arglist *parsed
561)
562{
563 char *transport;
564
565 if (parsed == NULL) {
566 printk(UM_KERN_ERR "no parsed config for unit %d\n", unit);
567 return NULL;
568 }
569 transport = uml_vector_fetch_arg(parsed, "transport");
570 if (transport == NULL) {
571 printk(UM_KERN_ERR "missing transport for unit %d\n", unit);
572 return NULL;
573 }
574 if (strncmp(transport, TRANS_RAW, TRANS_RAW_LEN) == 0)
575 return user_init_raw_fds(parsed);
576 if (strncmp(transport, TRANS_HYBRID, TRANS_HYBRID_LEN) == 0)
577 return user_init_hybrid_fds(parsed);
578 if (strncmp(transport, TRANS_TAP, TRANS_TAP_LEN) == 0)
579 return user_init_tap_fds(parsed);
580 if (strncmp(transport, TRANS_GRE, TRANS_GRE_LEN) == 0)
581 return user_init_socket_fds(parsed, ID_GRE);
582 if (strncmp(transport, TRANS_L2TPV3, TRANS_L2TPV3_LEN) == 0)
583 return user_init_socket_fds(parsed, ID_L2TPV3);
584 if (strncmp(transport, TRANS_BESS, TRANS_BESS_LEN) == 0)
585 return user_init_unix_fds(parsed, ID_BESS);
586 return NULL;
587}
588
589
590int uml_vector_sendmsg(int fd, void *hdr, int flags)
591{
592 int n;
593
594 CATCH_EINTR(n = sendmsg(fd, (struct msghdr *) hdr, flags));
595 if ((n < 0) && (errno == EAGAIN))
596 return 0;
597 if (n >= 0)
598 return n;
599 else
600 return -errno;
601}
602
603int uml_vector_recvmsg(int fd, void *hdr, int flags)
604{
605 int n;
606 struct msghdr *msg = (struct msghdr *) hdr;
607
608 CATCH_EINTR(n = readv(fd, msg->msg_iov, msg->msg_iovlen));
609 if ((n < 0) && (errno == EAGAIN))
610 return 0;
611 if (n >= 0)
612 return n;
613 else
614 return -errno;
615}
616
617int uml_vector_writev(int fd, void *hdr, int iovcount)
618{
619 int n;
620
621 CATCH_EINTR(n = writev(fd, (struct iovec *) hdr, iovcount));
622 if ((n < 0) && ((errno == EAGAIN) || (errno == ENOBUFS)))
623 return 0;
624 if (n >= 0)
625 return n;
626 else
627 return -errno;
628}
629
630int uml_vector_sendmmsg(
631 int fd,
632 void *msgvec,
633 unsigned int vlen,
634 unsigned int flags)
635{
636 int n;
637
638 CATCH_EINTR(n = sendmmsg(fd, (struct mmsghdr *) msgvec, vlen, flags));
639 if ((n < 0) && ((errno == EAGAIN) || (errno == ENOBUFS)))
640 return 0;
641 if (n >= 0)
642 return n;
643 else
644 return -errno;
645}
646
647int uml_vector_recvmmsg(
648 int fd,
649 void *msgvec,
650 unsigned int vlen,
651 unsigned int flags)
652{
653 int n;
654
655 CATCH_EINTR(
656 n = recvmmsg(fd, (struct mmsghdr *) msgvec, vlen, flags, 0));
657 if ((n < 0) && (errno == EAGAIN))
658 return 0;
659 if (n >= 0)
660 return n;
661 else
662 return -errno;
663}
664int uml_vector_attach_bpf(int fd, void *bpf)
665{
666 struct sock_fprog *prog = bpf;
667
668 int err = setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, bpf, sizeof(struct sock_fprog));
669
670 if (err < 0)
671 printk(KERN_ERR BPF_ATTACH_FAIL, prog->len, prog->filter, fd, -errno);
672 return err;
673}
674
675int uml_vector_detach_bpf(int fd, void *bpf)
676{
677 struct sock_fprog *prog = bpf;
678
679 int err = setsockopt(fd, SOL_SOCKET, SO_DETACH_FILTER, bpf, sizeof(struct sock_fprog));
680 if (err < 0)
681 printk(KERN_ERR BPF_DETACH_FAIL, prog->len, prog->filter, fd, -errno);
682 return err;
683}
684void *uml_vector_default_bpf(void *mac)
685{
686 struct sock_filter *bpf;
687 uint32_t *mac1 = (uint32_t *)(mac + 2);
688 uint16_t *mac2 = (uint16_t *) mac;
689 struct sock_fprog *bpf_prog;
690
691 bpf_prog = uml_kmalloc(sizeof(struct sock_fprog), UM_GFP_KERNEL);
692 if (bpf_prog) {
693 bpf_prog->len = DEFAULT_BPF_LEN;
694 bpf_prog->filter = NULL;
695 } else {
696 return NULL;
697 }
698 bpf = uml_kmalloc(
699 sizeof(struct sock_filter) * DEFAULT_BPF_LEN, UM_GFP_KERNEL);
700 if (bpf) {
701 bpf_prog->filter = bpf;
702 /* ld [8] */
703 bpf[0] = (struct sock_filter){ 0x20, 0, 0, 0x00000008 };
704 /* jeq #0xMAC[2-6] jt 2 jf 5*/
705 bpf[1] = (struct sock_filter){ 0x15, 0, 3, ntohl(*mac1)};
706 /* ldh [6] */
707 bpf[2] = (struct sock_filter){ 0x28, 0, 0, 0x00000006 };
708 /* jeq #0xMAC[0-1] jt 4 jf 5 */
709 bpf[3] = (struct sock_filter){ 0x15, 0, 1, ntohs(*mac2)};
710 /* ret #0 */
711 bpf[4] = (struct sock_filter){ 0x6, 0, 0, 0x00000000 };
712 /* ret #0x40000 */
713 bpf[5] = (struct sock_filter){ 0x6, 0, 0, 0x00040000 };
714 } else {
715 kfree(bpf_prog);
716 bpf_prog = NULL;
717 }
718 return bpf_prog;
719}
720
721/* Note - this function requires a valid mac being passed as an arg */
722
723void *uml_vector_user_bpf(char *filename)
724{
725 struct sock_filter *bpf;
726 struct sock_fprog *bpf_prog;
727 struct stat statbuf;
728 int res, ffd = -1;
729
730 if (filename == NULL)
731 return NULL;
732
733 if (stat(filename, &statbuf) < 0) {
734 printk(KERN_ERR "Error %d reading bpf file", -errno);
735 return false;
736 }
737 bpf_prog = uml_kmalloc(sizeof(struct sock_fprog), UM_GFP_KERNEL);
738 if (bpf_prog != NULL) {
739 bpf_prog->len = statbuf.st_size / sizeof(struct sock_filter);
740 bpf_prog->filter = NULL;
741 }
742 ffd = os_open_file(filename, of_read(OPENFLAGS()), 0);
743 if (ffd < 0) {
744 printk(KERN_ERR "Error %d opening bpf file", -errno);
745 goto bpf_failed;
746 }
747 bpf = uml_kmalloc(statbuf.st_size, UM_GFP_KERNEL);
748 if (bpf == NULL) {
749 printk(KERN_ERR "Failed to allocate bpf buffer");
750 goto bpf_failed;
751 }
752 bpf_prog->filter = bpf;
753 res = os_read_file(ffd, bpf, statbuf.st_size);
754 if (res < statbuf.st_size) {
755 printk(KERN_ERR "Failed to read bpf program %s, error %d", filename, res);
756 kfree(bpf);
757 goto bpf_failed;
758 }
759 os_close_file(ffd);
760 return bpf_prog;
761bpf_failed:
762 if (ffd > 0)
763 os_close_file(ffd);
764 kfree(bpf_prog);
765 return NULL;
766}