xutils.c

   1 /*
   2  * netsniff-ng - the packet sniffing beast
   3  * Copyright 2009, 2010 Daniel Borkmann.
   4  * Copyright 2009, 2010 Emmanuel Roullit.
   5  * Copyright 2010 Marek Polacek.
   6  * Subject to the GPL, version 2.
   7  */
   8
   9 #define _GNU_SOURCE
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <stdint.h>
  13 #include <fcntl.h>
  14 #include <string.h>
  15 #include <unistd.h>
  16 #include <errno.h>
  17 #include <stdarg.h>
  18 #include <ctype.h>
  19 #include <signal.h>
  20 #include <arpa/inet.h>
  21 #include <time.h>
  22 #include <sched.h>
  23 #include <limits.h>
  24 #include <stdbool.h>
  25 #include <netdb.h>
  26 #include <ifaddrs.h>
  27 #include <sys/time.h>
  28 #include <sys/socket.h>
  29 #include <sys/ioctl.h>
  30 #include <sys/mman.h>
  31 #include <sys/resource.h>
  32 #include <sys/epoll.h>
  33 #include <sys/syscall.h>
  34 #include <asm/unistd.h>
  35 #include <linux/if.h>
  36 #include <linux/socket.h>
  37 #include <linux/types.h>
  38 #include <linux/if_ether.h>
  39 #include <linux/if_packet.h>
  40 #include <linux/sockios.h>
  41 #include <netinet/tcp.h>
  42 #include <netinet/udp.h>
  43
  44 #include "die.h"
  45 #include "xutils.h"
  46 #include "ring.h"
  47 #include "built_in.h"
  48
  49 #define IOPRIO_CLASS_SHIFT      13
  50
  51 enum {
  52         ioprio_class_none,
  53         ioprio_class_rt,
  54         ioprio_class_be,
  55         ioprio_class_idle,
  56 };
  57
  58 enum {
  59         ioprio_who_process = 1,
  60         ioprio_who_pgrp,
  61         ioprio_who_user,
  62 };
  63
  64 enum {
  65         sock_rmem_max = 0,
  66         sock_rmem_def,
  67         sock_wmem_max,
  68         sock_wmem_def,
  69 };
  70
  71 #define SMEM_SUG_MAX    104857600
  72 #define SMEM_SUG_DEF    4194304
  73
  74 static const char *const to_prio[] = {
  75         "none",
  76         "realtime",
  77         "best-effort",
  78         "idle",
  79 };
  80
  81 static const char *const sock_mem[] = {
  82         "/proc/sys/net/core/rmem_max",
  83         "/proc/sys/net/core/rmem_default",
  84         "/proc/sys/net/core/wmem_max",
  85         "/proc/sys/net/core/wmem_default",
  86 };
  87
  88 int af_socket(int af)
  89 {
  90         int sock;
  91
  92         if (unlikely(af != AF_INET && af != AF_INET6))
  93                 panic("Wrong AF socket type!\n");
  94
  95         sock = socket(af, SOCK_DGRAM, 0);
  96         if (unlikely(sock < 0))
  97                 panic("Creation AF socket failed!\n");
  98
  99         return sock;
 100 }
 101
 102 int pf_socket(void)
 103 {
 104         int sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
 105         if (unlikely(sock < 0))
 106                 panic("Creation of PF socket failed!\n");
 107
 108         return sock;
 109 }
 110
 111 void set_sock_prio(int fd, int prio)
 112 {
 113         int val = prio;
 114         setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &val, sizeof(val));
 115 }
 116
 117 void set_udp_cork(int fd)
 118 {
 119         int state = 1;
 120         setsockopt(fd, IPPROTO_UDP, UDP_CORK, &state, sizeof(state));
 121 }
 122
 123 void set_udp_uncork(int fd)
 124 {
 125         int state = 0;
 126         setsockopt(fd, IPPROTO_UDP, UDP_CORK, &state, sizeof(state));
 127 }
 128
 129 void set_tcp_cork(int fd)
 130 {
 131         int state = 1;
 132         setsockopt(fd, IPPROTO_TCP, TCP_CORK, &state, sizeof(state));
 133 }
 134
 135 void set_tcp_uncork(int fd)
 136 {
 137         int state = 0;
 138         setsockopt(fd, IPPROTO_TCP, TCP_CORK, &state, sizeof(state));
 139 }
 140
 141 void set_sock_cork(int fd, int udp)
 142 {
 143         if (!!udp)
 144                 set_udp_cork(fd);
 145         else
 146                 set_tcp_cork(fd);
 147 }
 148
 149 void set_sock_uncork(int fd, int udp)
 150 {
 151         if (!!udp)
 152                 set_udp_uncork(fd);
 153         else
 154                 set_tcp_uncork(fd);
 155 }
 156
 157 int set_nonblocking(int fd)
 158 {
 159         int ret = fcntl(fd, F_SETFL, fcntl(fd, F_GETFD, 0) | O_NONBLOCK);
 160         if (unlikely(ret < 0))
 161                 panic("Cannot fcntl!\n");
 162
 163         return 0;
 164 }
 165
 166 int set_nonblocking_sloppy(int fd)
 167 {
 168         return fcntl(fd, F_SETFL, fcntl(fd, F_GETFD, 0) | O_NONBLOCK);
 169 }
 170
 171 void set_socket_keepalive(int fd)
 172 {
 173         int one = 1;
 174         setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &one, sizeof(one));
 175 }
 176
 177 void set_tcp_nodelay(int fd)
 178 {
 179         int one = 1;
 180         setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one));
 181 }
 182
 183 int set_ipv6_only(int fd)
 184 {
 185         int one = 1;
 186         return setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &one, sizeof(one));
 187 }
 188
 189 int set_reuseaddr(int fd)
 190 {
 191         int ret, one = 1;
 192
 193         ret = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
 194         if (unlikely(ret < 0))
 195                 panic("Cannot reuse addr!\n");
 196
 197         return 0;
 198 }
 199
 200 void set_mtu_disc_dont(int fd)
 201 {
 202         int mtu = IP_PMTUDISC_DONT;
 203         setsockopt(fd, SOL_IP, IP_MTU_DISCOVER, &mtu, sizeof(mtu));
 204 }
 205
 206 void set_epoll_descriptor(int fd_epoll, int action, int fd_toadd, int events)
 207 {
 208         int ret;
 209         struct epoll_event ev;
 210
 211         memset(&ev, 0, sizeof(ev));
 212         ev.events = events;
 213         ev.data.fd = fd_toadd;
 214
 215         ret = epoll_ctl(fd_epoll, action, fd_toadd, &ev);
 216         if (ret < 0)
 217                 panic("Cannot add socket for epoll!\n");
 218 }
 219
 220 int set_epoll_descriptor2(int fd_epoll, int action, int fd_toadd, int events)
 221 {
 222         struct epoll_event ev;
 223
 224         memset(&ev, 0, sizeof(ev));
 225         ev.events = events;
 226         ev.data.fd = fd_toadd;
 227
 228         return epoll_ctl(fd_epoll, action, fd_toadd, &ev);
 229 }
 230
 231 u32 wireless_bitrate(const char *ifname)
 232 {
 233         int sock, ret, rate_in_mbit;
 234         struct iwreq iwr;
 235
 236         sock = af_socket(AF_INET);
 237
 238         memset(&iwr, 0, sizeof(iwr));
 239         strlcpy(iwr.ifr_name, ifname, IFNAMSIZ);
 240
 241         ret = ioctl(sock, SIOCGIWRATE, &iwr);
 242         if (!ret)
 243                 rate_in_mbit = iwr.u.bitrate.value / 1000000;
 244         else
 245                 rate_in_mbit = 0;
 246
 247         close(sock);
 248
 249         return rate_in_mbit;
 250 }
 251
 252 void drop_privileges(bool enforce, uid_t uid, gid_t gid)
 253 {
 254         if (enforce) {
 255                 if (uid == getuid())
 256                         panic("Uid cannot be the same as the current user!\n");
 257                 if (gid == getgid())
 258                         panic("Gid cannot be the same as the current user!\n");
 259         }
 260         if (setgid(gid) != 0)
 261                 panic("Unable to drop group privileges: %s!\n", strerror(errno));
 262         if (setuid(uid) != 0)
 263                 panic("Unable to drop user privileges: %s!\n", strerror(errno));
 264 }
 265
 266 int get_system_socket_mem(int which)
 267 {
 268         int fd, val = -1;
 269         ssize_t ret;
 270         const char *file = sock_mem[which];
 271         char buff[64];
 272
 273         fd = open(file, O_RDONLY);
 274         if (fd < 0)
 275                 return val;
 276
 277         ret = read(fd, buff, sizeof(buff));
 278         if (ret > 0)
 279                 val = atoi(buff);
 280
 281         close(fd);
 282         return val;
 283 }
 284
 285 void set_system_socket_mem(int which, int val)
 286 {
 287         int fd;
 288         const char *file = sock_mem[which];
 289         ssize_t ret;
 290         char buff[64];
 291
 292         fd = open(file, O_WRONLY);
 293         if (fd < 0)
 294                 return;
 295
 296         memset(buff, 0, sizeof(buff));
 297         slprintf(buff, sizeof(buff), "%d", val);
 298
 299         ret = write(fd, buff, strlen(buff));
 300         ret = ret;
 301
 302         close(fd);
 303 }
 304
 305 int wireless_sigqual(const char *ifname, struct iw_statistics *stats)
 306 {
 307         int ret, sock;
 308         struct iwreq iwr;
 309
 310         sock = af_socket(AF_INET);
 311
 312         memset(&iwr, 0, sizeof(iwr));
 313         strlcpy(iwr.ifr_name, ifname, IFNAMSIZ);
 314
 315         iwr.u.data.pointer = (caddr_t) stats;
 316         iwr.u.data.length = sizeof(*stats);
 317         iwr.u.data.flags = 1;
 318
 319         ret = ioctl(sock, SIOCGIWSTATS, &iwr);
 320
 321         close(sock);
 322
 323         return ret;
 324 }
 325
 326 int wireless_rangemax_sigqual(const char *ifname)
 327 {
 328         int ret, sock, sigqual;
 329         struct iwreq iwr;
 330         struct iw_range iwrange;
 331
 332         sock = af_socket(AF_INET);
 333
 334         memset(&iwrange, 0, sizeof(iwrange));
 335
 336         memset(&iwr, 0, sizeof(iwr));
 337         strlcpy(iwr.ifr_name, ifname, IFNAMSIZ);
 338
 339         iwr.u.data.pointer = (caddr_t) &iwrange;
 340         iwr.u.data.length = sizeof(iwrange);
 341         iwr.u.data.flags = 0;
 342
 343         ret = ioctl(sock, SIOCGIWRANGE, &iwr);
 344         if (!ret)
 345                 sigqual = iwrange.max_qual.qual;
 346         else
 347                 sigqual = 0;
 348
 349         close(sock);
 350
 351         return sigqual;
 352 }
 353
 354 u32 ethtool_bitrate(const char *ifname)
 355 {
 356         int ret, sock, bitrate;
 357         struct ifreq ifr;
 358         struct ethtool_cmd ecmd;
 359
 360         sock = af_socket(AF_INET);
 361
 362         memset(&ecmd, 0, sizeof(ecmd));
 363
 364         memset(&ifr, 0, sizeof(ifr));
 365         strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 366
 367         ecmd.cmd = ETHTOOL_GSET;
 368         ifr.ifr_data = (char *) &ecmd;
 369
 370         ret = ioctl(sock, SIOCETHTOOL, &ifr);
 371         if (ret) {
 372                 bitrate = 0;
 373                 goto out;
 374         }
 375
 376         switch (ecmd.speed) {
 377         case SPEED_10:
 378         case SPEED_100:
 379         case SPEED_1000:
 380         case SPEED_2500:
 381         case SPEED_10000:
 382                 bitrate = ecmd.speed;
 383                 break;
 384         default:
 385                 bitrate = 0;
 386                 break;
 387         };
 388 out:
 389         close(sock);
 390
 391         return bitrate;
 392 }
 393
 394 int ethtool_link(const char *ifname)
 395 {
 396         int ret, sock;
 397         struct ifreq ifr;
 398         struct ethtool_value ecmd;
 399
 400         sock = af_socket(AF_INET);
 401
 402         memset(&ecmd, 0, sizeof(ecmd));
 403
 404         memset(&ifr, 0, sizeof(ifr));
 405         strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 406
 407         ecmd.cmd = ETHTOOL_GLINK;
 408         ifr.ifr_data = (char *) &ecmd;
 409
 410         ret = ioctl(sock, SIOCETHTOOL, &ifr);
 411         if (ret)
 412                 ret = -EINVAL;
 413         else
 414                 ret = !!ecmd.data;
 415
 416         close(sock);
 417         return ret;
 418 }
 419
 420 int ethtool_drvinf(const char *ifname, struct ethtool_drvinfo *drvinf)
 421 {
 422         int ret, sock;
 423         struct ifreq ifr;
 424
 425         sock = af_socket(AF_INET);
 426
 427         memset(drvinf, 0, sizeof(*drvinf));
 428
 429         memset(&ifr, 0, sizeof(ifr));
 430         strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 431
 432         drvinf->cmd = ETHTOOL_GDRVINFO;
 433         ifr.ifr_data = (char *) drvinf;
 434
 435         ret = ioctl(sock, SIOCETHTOOL, &ifr);
 436
 437         close(sock);
 438
 439         return ret;
 440 }
 441
 442 u32 device_bitrate(const char *ifname)
 443 {
 444         u32 speed_c, speed_w;
 445
 446         speed_c = ethtool_bitrate(ifname);
 447         speed_w = wireless_bitrate(ifname);
 448
 449         return (speed_c == 0 ? speed_w : speed_c);
 450 }
 451
 452 int device_ifindex(const char *ifname)
 453 {
 454         int ret, sock, index;
 455         struct ifreq ifr;
 456
 457         if (!strncmp("any", ifname, strlen("any")))
 458                 return 0;
 459
 460         sock = af_socket(AF_INET);
 461
 462         memset(&ifr, 0, sizeof(ifr));
 463         strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 464
 465         ret = ioctl(sock, SIOCGIFINDEX, &ifr);
 466         if (!ret)
 467                 index = ifr.ifr_ifindex;
 468         else
 469                 index = -1;
 470
 471         close(sock);
 472
 473         return index;
 474 }
 475
 476 static int __device_address6(const char *ifname, struct sockaddr_storage *ss)
 477 {
 478         int ret, family, found = -EINVAL;
 479         struct ifaddrs *ifaddr, *ifa;
 480
 481         ret = getifaddrs(&ifaddr);
 482         if (ret < 0)
 483                 panic("Cannot get device addresses for IPv6!\n");
 484
 485         for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
 486                 family = ifa->ifa_addr->sa_family;
 487                 if (family != AF_INET6)
 488                         continue;
 489                 if (strcmp(ifa->ifa_name, ifname))
 490                         continue;
 491
 492                 memcpy(ss, ifa->ifa_addr, sizeof(*ss));
 493                 found = 0;
 494                 break;
 495         }
 496
 497         freeifaddrs(ifaddr);
 498         return found;
 499 }
 500
 501 int device_address(const char *ifname, int af, struct sockaddr_storage *ss)
 502 {
 503         int ret, sock;
 504         struct ifreq ifr;
 505
 506         if (!ss)
 507                 return -EINVAL;
 508         if (!strncmp("any", ifname, strlen("any")))
 509                 return -EINVAL;
 510         if (af == AF_INET6)
 511                 return __device_address6(ifname, ss);
 512
 513         sock = af_socket(af);
 514
 515         memset(&ifr, 0, sizeof(ifr));
 516         strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 517
 518         ifr.ifr_addr.sa_family = af;
 519
 520         ret = ioctl(sock, SIOCGIFADDR, &ifr);
 521         if (!ret)
 522                 memcpy(ss, &ifr.ifr_addr, sizeof(ifr.ifr_addr));
 523
 524         close(sock);
 525
 526         return ret;
 527 }
 528
 529 int device_mtu(const char *ifname)
 530 {
 531         int ret, sock, mtu;
 532         struct ifreq ifr;
 533
 534         sock = af_socket(AF_INET);
 535
 536         memset(&ifr, 0, sizeof(ifr));
 537         strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 538
 539         ret = ioctl(sock, SIOCGIFMTU, &ifr);
 540         if (!ret)
 541                 mtu = ifr.ifr_mtu;
 542         else
 543                 mtu = 0;
 544
 545         close(sock);
 546
 547         return mtu;
 548 }
 549
 550 short device_get_flags(const char *ifname)
 551 {
 552         /* Really, it's short! Look at struct ifreq */
 553         short flags;
 554         int ret, sock;
 555         struct ifreq ifr;
 556
 557         sock = af_socket(AF_INET);
 558
 559         memset(&ifr, 0, sizeof(ifr));
 560         strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 561
 562         ret = ioctl(sock, SIOCGIFFLAGS, &ifr);
 563         if (!ret)
 564                 flags = ifr.ifr_flags;
 565         else
 566                 flags = 0;
 567
 568         close(sock);
 569
 570         return flags;
 571 }
 572
 573 void device_set_flags(const char *ifname, const short flags)
 574 {
 575         int ret, sock;
 576         struct ifreq ifr;
 577
 578         sock = af_socket(AF_INET);
 579
 580         memset(&ifr, 0, sizeof(ifr));
 581         strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 582
 583         ifr.ifr_flags = flags;
 584
 585         ret = ioctl(sock, SIOCSIFFLAGS, &ifr);
 586         if (ret < 0)
 587                 panic("Cannot set NIC flags!\n");
 588
 589         close(sock);
 590 }
 591
 592 int device_irq_number(const char *ifname)
 593 {
 594         /*
 595          * Since fetching IRQ numbers from SIOCGIFMAP is deprecated and not
 596          * supported anymore, we need to grab them from procfs
 597          */
 598         int irq = 0;
 599         char *buffp;
 600         char buff[512];
 601         char sysname[512];
 602         FILE *fp;
 603
 604         if (!strncmp("lo", ifname, strlen("lo")))
 605                 return 0;
 606
 607         fp = fopen("/proc/interrupts", "r");
 608         if (!fp)
 609                 panic("Cannot open /proc/interrupts!\n");
 610
 611         memset(buff, 0, sizeof(buff));
 612         while (fgets(buff, sizeof(buff), fp) != NULL) {
 613                 buff[sizeof(buff) - 1] = 0;
 614
 615                 if (strstr(buff, ifname) == NULL)
 616                         continue;
 617
 618                 buffp = buff;
 619                 while (*buffp != ':')
 620                         buffp++;
 621                 *buffp = 0;
 622                 irq = atoi(buff);
 623
 624                 memset(buff, 0, sizeof(buff));
 625         }
 626
 627         fclose(fp);
 628
 629         if (irq != 0)
 630                 return irq;
 631         /*
 632          * Try sysfs as fallback. Probably wireless devices will be found
 633          * here. We return silently if it fails ...
 634          */
 635         slprintf(sysname, sizeof(sysname), "/sys/class/net/%s/device/irq",
 636                  ifname);
 637
 638         fp = fopen(sysname, "r");
 639         if (!fp)
 640                 return -ENOENT;
 641
 642         memset(buff, 0, sizeof(buff));
 643         if(fgets(buff, sizeof(buff), fp) != NULL) {
 644                 buff[sizeof(buff) - 1] = 0;
 645                 irq = atoi(buff);
 646         }
 647
 648         fclose(fp);
 649
 650         return irq;
 651 }
 652
 653 int device_set_irq_affinity_list(int irq, unsigned long from, unsigned long to)
 654 {
 655         int ret, fd;
 656         char file[256], list[64];
 657
 658         slprintf(file, sizeof(file), "/proc/irq/%d/smp_affinity_list", irq);
 659         slprintf(list, sizeof(list), "%lu-%lu\n", from, to);
 660
 661         fd = open(file, O_WRONLY);
 662         if (fd < 0)
 663                 return -ENOENT;
 664
 665         ret = write(fd, list, strlen(list));
 666
 667         close(fd);
 668         return ret;
 669 }
 670
 671 int device_bind_irq_to_cpu(int irq, int cpu)
 672 {
 673         int ret;
 674         char buff[256];
 675         char file[256];
 676         FILE *fp;
 677
 678         /* Note: first CPU begins with CPU 0 */
 679         if (irq < 0 || cpu < 0)
 680                 return -EINVAL;
 681
 682         memset(file, 0, sizeof(file));
 683         memset(buff, 0, sizeof(buff));
 684
 685         /* smp_affinity starts counting with CPU 1, 2, ... */
 686         cpu = cpu + 1;
 687         sprintf(file, "/proc/irq/%d/smp_affinity", irq);
 688
 689         fp = fopen(file, "w");
 690         if (!fp)
 691                 return -ENOENT;
 692
 693         sprintf(buff, "%d", cpu);
 694         ret = fwrite(buff, sizeof(buff), 1, fp);
 695
 696         fclose(fp);
 697         return (ret > 0 ? 0 : ret);
 698 }
 699
 700 void sock_print_net_stats(int sock, unsigned long skipped)
 701 {
 702         int ret;
 703         struct tpacket_stats kstats;
 704
 705         socklen_t slen = sizeof(kstats);
 706
 707         memset(&kstats, 0, sizeof(kstats));
 708         ret = getsockopt(sock, SOL_PACKET, PACKET_STATISTICS, &kstats, &slen);
 709         if (ret > -1) {
 710                 uint64_t packets = kstats.tp_packets;
 711                 uint64_t drops = kstats.tp_drops;
 712
 713                 printf("\r%12ld  packets incoming\n", packets);
 714                 printf("\r%12ld  packets passed filter\n", packets - drops - skipped);
 715                 printf("\r%12ld  packets failed filter (out of space)\n", drops + skipped);
 716                 if (kstats.tp_packets > 0)
 717                         printf("\r%12.4lf%\% packet droprate\n", (1.0 * drops / packets) * 100.0);
 718         }
 719 }
 720
 721 void register_signal(int signal, void (*handler)(int))
 722 {
 723         sigset_t block_mask;
 724         struct sigaction saction;
 725
 726         sigfillset(&block_mask);
 727
 728         saction.sa_handler = handler;
 729         saction.sa_mask = block_mask;
 730         saction.sa_flags = SA_RESTART;
 731
 732         sigaction(signal, &saction, NULL);
 733 }
 734
 735 void register_signal_f(int signal, void (*handler)(int), int flags)
 736 {
 737         sigset_t block_mask;
 738         struct sigaction saction;
 739
 740         sigfillset(&block_mask);
 741
 742         saction.sa_handler = handler;
 743         saction.sa_mask = block_mask;
 744         saction.sa_flags = flags;
 745
 746         sigaction(signal, &saction, NULL);
 747 }
 748
 749 short enter_promiscuous_mode(char *ifname)
 750 {
 751         short ifflags;
 752
 753         if (!strncmp("any", ifname, strlen("any")))
 754                 return 0;
 755
 756         ifflags = device_get_flags(ifname);
 757         device_set_flags(ifname, ifflags | IFF_PROMISC);
 758
 759         return ifflags;
 760 }
 761
 762 void leave_promiscuous_mode(char *ifname, short oldflags)
 763 {
 764         if (!strncmp("any", ifname, strlen("any")))
 765                 return;
 766
 767         device_set_flags(ifname, oldflags);
 768 }
 769
 770 int device_up_and_running(char *ifname)
 771 {
 772         if (!ifname)
 773                 return -EINVAL;
 774         if (!strncmp("any", ifname, strlen("any")))
 775                 return 1;
 776
 777         return (device_get_flags(ifname) & (IFF_UP | IFF_RUNNING)) == (IFF_UP | IFF_RUNNING);
 778 }
 779
 780 void cpu_affinity(int cpu)
 781 {
 782         int ret;
 783         cpu_set_t cpu_bitmask;
 784
 785         CPU_ZERO(&cpu_bitmask);
 786         CPU_SET(cpu, &cpu_bitmask);
 787
 788         ret = sched_setaffinity(getpid(), sizeof(cpu_bitmask),
 789                                 &cpu_bitmask);
 790         if (ret)
 791                 panic("Can't set this cpu affinity!\n");
 792 }
 793
 794 int set_proc_prio(int priority)
 795 {
 796         int ret = setpriority(PRIO_PROCESS, getpid(), priority);
 797         if (ret)
 798                 panic("Can't set nice val to %i!\n", priority);
 799
 800         return 0;
 801 }
 802
 803 int set_sched_status(int policy, int priority)
 804 {
 805         int ret, min_prio, max_prio;
 806         struct sched_param sp;
 807
 808         max_prio = sched_get_priority_max(policy);
 809         min_prio = sched_get_priority_min(policy);
 810
 811         if (max_prio == -1 || min_prio == -1)
 812                 printf("Cannot determine scheduler prio limits!\n");
 813         else if (priority < min_prio)
 814                 priority = min_prio;
 815         else if (priority > max_prio)
 816                 priority = max_prio;
 817
 818         memset(&sp, 0, sizeof(sp));
 819         sp.sched_priority = priority;
 820
 821         ret = sched_setscheduler(getpid(), policy, &sp);
 822         if (ret) {
 823                 printf("Cannot set scheduler policy!\n");
 824                 return -EINVAL;
 825         }
 826
 827         ret = sched_setparam(getpid(), &sp);
 828         if (ret) {
 829                 printf("Cannot set scheduler prio!\n");
 830                 return -EINVAL;
 831         }
 832
 833         return 0;
 834 }
 835
 836 static inline int ioprio_set(int which, int who, int ioprio)
 837 {
 838         return syscall(SYS_ioprio_set, which, who, ioprio);
 839 }
 840
 841 static inline int ioprio_get(int which, int who)
 842 {
 843         return syscall(SYS_ioprio_get, which, who);
 844 }
 845
 846 static void ioprio_setpid(pid_t pid, int ioprio, int ioclass)
 847 {
 848         int ret = ioprio_set(ioprio_who_process, pid,
 849                              ioprio | ioclass << IOPRIO_CLASS_SHIFT);
 850         if (ret < 0)
 851                 panic("Failed to set io prio for pid!\n");
 852 }
 853
 854 void ioprio_print(void)
 855 {
 856         int ioprio = ioprio_get(ioprio_who_process, getpid());
 857         if (ioprio < 0)
 858                 panic("Failed to fetch io prio for pid!\n");
 859         else {
 860                 int ioclass = ioprio >> IOPRIO_CLASS_SHIFT;
 861                 if (ioclass != ioprio_class_idle) {
 862                         ioprio &= 0xff;
 863                         printf("%s: prio %d\n", to_prio[ioclass], ioprio);
 864                 } else
 865                         printf("%s\n", to_prio[ioclass]);
 866         }
 867 }
 868
 869 void set_ioprio_rt(void)
 870 {
 871         ioprio_setpid(getpid(), 4, ioprio_class_rt);
 872 }
 873
 874 void set_ioprio_be(void)
 875 {
 876         ioprio_setpid(getpid(), 4, ioprio_class_be);
 877 }
 878
 879 void xlockme(void)
 880 {
 881         if (mlockall(MCL_CURRENT | MCL_FUTURE) != 0)
 882                 panic("Cannot lock pages!\n");
 883 }
 884
 885 void xunlockme(void)
 886 {
 887         munlockall();
 888 }
 889
 890 size_t strlcpy(char *dest, const char *src, size_t size)
 891 {
 892         size_t ret = strlen(src);
 893
 894         if (size) {
 895                 size_t len = (ret >= size) ? size - 1 : ret;
 896
 897                 memcpy(dest, src, len);
 898                 dest[len] = '\0';
 899         }
 900
 901         return ret;
 902 }
 903
 904 static inline int vslprintf(char *dst, size_t size, const char *fmt, va_list ap)
 905 {
 906         int ret;
 907
 908         ret = vsnprintf(dst, size, fmt, ap);
 909         dst[size - 1] = '\0';
 910
 911         return ret;
 912 }
 913
 914 int slprintf(char *dst, size_t size, const char *fmt, ...)
 915 {
 916         int ret;
 917         va_list ap;
 918
 919         va_start(ap, fmt);
 920         ret = vslprintf(dst, size, fmt, ap);
 921         va_end(ap);
 922
 923         return ret;
 924 }
 925
 926 int slprintf_nocheck(char *dst, size_t size, const char *fmt, ...)
 927 {
 928         int ret;
 929         va_list ap;
 930
 931         va_start(ap, fmt);
 932         ret = vslprintf(dst, size, fmt, ap);
 933         va_end(ap);
 934
 935         return ret;
 936 }
 937
 938 noinline void *xmemset(void *s, int c, size_t n)
 939 {
 940         size_t i;
 941         uint8_t *ptr = s;
 942
 943         for (i = 0; i < n; ++i)
 944                 ptr[i] = (uint8_t) c;
 945
 946         return ptr;
 947 }
 948
 949 char *strtrim_right(char *p, char c)
 950 {
 951         char *end;
 952         size_t len;
 953
 954         len = strlen(p);
 955         while (*p && len) {
 956                 end = p + len - 1;
 957                 if (c == *end)
 958                         *end = 0;
 959                 else
 960                         break;
 961                 len = strlen(p);
 962         }
 963
 964         return p;
 965 }
 966
 967 int get_default_sched_policy(void)
 968 {
 969         return SCHED_FIFO;
 970 }
 971
 972 int get_default_sched_prio(void)
 973 {
 974         return sched_get_priority_max(get_default_sched_policy());
 975 }
 976
 977 int get_number_cpus(void)
 978 {
 979         return sysconf(_SC_NPROCESSORS_CONF);
 980 }
 981
 982 int get_number_cpus_online(void)
 983 {
 984         return sysconf(_SC_NPROCESSORS_ONLN);
 985 }
 986
 987 int get_default_proc_prio(void)
 988 {
 989         return -20;
 990 }
 991
 992 void set_system_socket_memory(int *vals, size_t len)
 993 {
 994         bug_on(len != 4);
 995
 996         if ((vals[0] = get_system_socket_mem(sock_rmem_max)) < SMEM_SUG_MAX)
 997                 set_system_socket_mem(sock_rmem_max, SMEM_SUG_MAX);
 998         if ((vals[1] = get_system_socket_mem(sock_rmem_def)) < SMEM_SUG_DEF)
 999                 set_system_socket_mem(sock_rmem_def, SMEM_SUG_DEF);
1000         if ((vals[2] = get_system_socket_mem(sock_wmem_max)) < SMEM_SUG_MAX)
1001                 set_system_socket_mem(sock_wmem_max, SMEM_SUG_MAX);
1002         if ((vals[3] = get_system_socket_mem(sock_wmem_def)) < SMEM_SUG_DEF)
1003                 set_system_socket_mem(sock_wmem_def, SMEM_SUG_DEF);
1004 }
1005
1006 void reset_system_socket_memory(int *vals, size_t len)
1007 {
1008         bug_on(len != 4);
1009
1010         set_system_socket_mem(sock_rmem_max, vals[0]);
1011         set_system_socket_mem(sock_rmem_def, vals[1]);
1012         set_system_socket_mem(sock_wmem_max, vals[2]);
1013         set_system_socket_mem(sock_wmem_def, vals[3]);
1014 }
1015
1016 void set_itimer_interval_value(struct itimerval *itimer, unsigned long sec,
1017                                unsigned long usec)
1018 {
1019         itimer->it_interval.tv_sec = sec;
1020         itimer->it_interval.tv_usec = usec;
1021
1022         itimer->it_value.tv_sec = sec;
1023         itimer->it_value.tv_usec = usec;
1024 }