arch/um/drivers/vector_user.c

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