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