/
githubmirror
/
numactl
Обзор
Документация
Войти
/
githubmirror
/
numactl
Код
Запросы
0
Пакеты
0
Релизы
0
Аналитика
Безопасность
v2.0.8
affinity.c
343 строки
8 KB
Petr Holasek
libnuma: numa_parse_cpustring and similar should take a const char* parameter
24 июл 2014, 01:36
24 июл 2014, 01:36
2255817
Код
Авторство
О чём код?
/* Support for specifying IO affinity by various means. Copyright 2010 Intel Corporation Author: Andi Kleen libnuma is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; version 2.1. libnuma is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should find a copy of v2.1 of the GNU Lesser General Public License somewhere on your Linux system; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* Notebook: - Separate real errors from no NUMA with fallback - Infiniband - FCoE? - Support for other special IO devices - Specifying cpu subsets inside the IO node? - Handle multiple IO nodes (needs kernel changes) - Better support for multi-path IO? */ #define _GNU_SOURCE 1 #include <string.h> #include <errno.h> #include <sys/stat.h> #include <netdb.h> #include <unistd.h> #include <stdio.h> #include <stdlib.h> #include <sys/socket.h> #include <sys/ioctl.h> #include <net/if.h> #include <dirent.h> #include <linux/rtnetlink.h> #include <linux/netlink.h> #include <sys/types.h> #include <ctype.h> #include <assert.h> #include <regex.h> #include "numa.h" #include "numaint.h" #include "sysfs.h" #include "affinity.h" #include "rtnetlink.h" static int badchar(const char *s) { if (strpbrk(s, "/.")) return 1; return 0; } static int node_parse_failure(int ret, char *cls, const char *dev) { if (!cls) cls = ""; if (ret == -2) numa_warn(W_node_parse1, "Kernel does not know node mask for%s%s device `%s'", *cls ? " " : "", cls, dev); else numa_warn(W_node_parse2, "Cannot read node mask for %s device `%s'", cls, dev); return -1; } /* Generic sysfs class lookup */ static int affinity_class(struct bitmask *mask, char *cls, const const char *dev) { int ret; while (isspace(*dev)) dev++; if (badchar(dev)) { numa_warn(W_badchar, "Illegal characters in `%s' specification", dev); return -1; } /* Somewhat hackish: extract device from symlink path. Better would be a direct backlink. This knows slightly too much about the actual sysfs layout. */ char path[1024]; char *fn = NULL; if (asprintf(&fn, "/sys/class/%s/%s", cls, dev) > 0 && readlink(fn, path, sizeof path) > 0) { regex_t re; regmatch_t match[2]; char *p; regcomp(&re, "(/devices/pci[0-9a-fA-F:/]+\\.[0-9]+)/", REG_EXTENDED); ret = regexec(&re, path, 2, match, 0); regfree(&re); if (ret == 0) { free(fn); assert(match[0].rm_so > 0); assert(match[0].rm_eo > 0); path[match[1].rm_eo + 1] = 0; p = path + match[0].rm_so; ret = sysfs_node_read(mask, "/sys/%s/numa_node", p); if (ret < 0) return node_parse_failure(ret, NULL, p); return ret; } } free(fn); ret = sysfs_node_read(mask, "/sys/class/%s/%s/device/numa_node", cls, dev); if (ret < 0) return node_parse_failure(ret, cls, dev); return 0; } /* Turn file (or device node) into class name */ static int affinity_file(struct bitmask *mask, char *cls, const char *file) { struct stat st; DIR *dir; int n; unsigned maj = 0, min = 0; dev_t d; struct dirent de, *dep; cls = "block"; char fn[sizeof("/sys/class/") + strlen(cls)]; if (stat(file, &st) < 0) { numa_warn(W_blockdev1, "Cannot stat file %s", file); return -1; } d = st.st_dev; if (S_ISCHR(st.st_mode)) { /* Better choice than misc? Most likely misc will not work anyways unless the kernel is fixed. */ cls = "misc"; d = st.st_rdev; } else if (S_ISBLK(st.st_mode)) d = st.st_rdev; sprintf(fn, "/sys/class/%s", cls); dir = opendir(fn); if (!dir) { numa_warn(W_blockdev2, "Cannot enumerate %s devices in sysfs", cls); return -1; } while (readdir_r(dir, &de, &dep) == 0 && dep) { char *name = dep->d_name; if (*name == '.') continue; char *dev; char fn2[sizeof("/sys/class/block//dev") + strlen(name)]; n = -1; if (sprintf(fn2, "/sys/class/block/%s/dev", name) < 0) break; dev = sysfs_read(fn2); if (dev) { n = sscanf(dev, "%u:%u", &maj, &min); free(dev); } if (n != 2) { numa_warn(W_blockdev3, "Cannot parse sysfs device %s", name); continue; } if (major(d) != maj || minor(d) != min) continue; closedir(dir); return affinity_class(mask, "block", name); } closedir(dir); numa_warn(W_blockdev5, "Cannot find block device %x:%x in sysfs for `%s'", maj, min, file); return -1; } /* Look up interface of route using rtnetlink. */ static int find_route(struct sockaddr *dst, int *iifp) { struct rtattr *rta; const int hdrlen = NLMSG_LENGTH(sizeof(struct rtmsg)); struct { struct nlmsghdr msg; struct rtmsg rt; char buf[256]; } req = { .msg = { .nlmsg_len = hdrlen, .nlmsg_type = RTM_GETROUTE, .nlmsg_flags = NLM_F_REQUEST, }, .rt = { .rtm_family = dst->sa_family, }, }; struct sockaddr_nl adr = { .nl_family = AF_NETLINK, }; if (rta_put_address(&req.msg, RTA_DST, dst) < 0) { numa_warn(W_netlink1, "Cannot handle network family %x", dst->sa_family); return -1; } if (rtnetlink_request(&req.msg, sizeof req, &adr) < 0) { numa_warn(W_netlink2, "Cannot request rtnetlink route: %s", strerror(errno)); return -1; } /* Fish the interface out of the netlink soup. */ rta = NULL; while ((rta = rta_get(&req.msg, rta, hdrlen)) != NULL) { if (rta->rta_type == RTA_OIF) { memcpy(iifp, RTA_DATA(rta), sizeof(int)); return 0; } } numa_warn(W_netlink3, "rtnetlink query did not return interface"); return -1; } static int iif_to_name(int iif, struct ifreq *ifr) { int n; int sk = socket(PF_INET, SOCK_DGRAM, 0); if (sk < 0) return -1; ifr->ifr_ifindex = iif; n = ioctl(sk, SIOCGIFNAME, ifr); close(sk); return n; } /* Resolve an IP address to the nodes of a network device. This generally only attempts to handle simple cases: no multi-path, no bounding etc. In these cases only the first interface or none is chosen. */ static int affinity_ip(struct bitmask *mask, char *cls, const char *id) { struct addrinfo *ai; int n; int iif; struct ifreq ifr; if ((n = getaddrinfo(id, NULL, NULL, &ai)) != 0) { numa_warn(W_net1, "Cannot resolve %s: %s", id, gai_strerror(n)); return -1; } if (find_route(&ai->ai_addr[0], &iif) < 0) goto out_ai; if (iif_to_name(iif, &ifr) < 0) { numa_warn(W_net2, "Cannot resolve network interface %d", iif); goto out_ai; } freeaddrinfo(ai); return affinity_class(mask, "net", ifr.ifr_name); out_ai: freeaddrinfo(ai); return -1; } /* Look up affinity for a PCI device */ static int affinity_pci(struct bitmask *mask, char *cls, const char *id) { unsigned seg, bus, dev, func; int n, ret; /* Func is optional. */ if ((n = sscanf(id, "%x:%x:%x.%x",&seg,&bus,&dev,&func)) == 4 || n == 3) { if (n == 3) func = 0; } /* Segment is optional too */ else if ((n = sscanf(id, "%x:%x.%x",&bus,&dev,&func)) == 3 || n == 2) { seg = 0; if (n == 2) func = 0; } else { numa_warn(W_pci1, "Cannot parse PCI device `%s'", id); return -1; } ret = sysfs_node_read(mask, "/sys/devices/pci%04x:%02x/%04x:%02x:%02x.%x/numa_node", seg, bus, seg, bus, dev, func); if (ret < 0) return node_parse_failure(ret, cls, id); return 0; } static struct handler { char first; char *name; char *cls; int (*handler)(struct bitmask *mask, char *cls, const char *desc); } handlers[] = { { 'n', "netdev:", "net", affinity_class }, { 'i', "ip:", NULL, affinity_ip }, { 'f', "file:", NULL, affinity_file }, { 'b', "block:", "block", affinity_class }, { 'p', "pci:", NULL, affinity_pci }, {} }; hidden int resolve_affinity(const char *id, struct bitmask *mask) { struct handler *h; for (h = &handlers[0]; h->first; h++) { int len; if (id[0] != h->first) continue; len = strlen(h->name); if (!strncmp(id, h->name, len)) { int ret = h->handler(mask, h->cls, id + len); if (ret == -2) { numa_warn(W_nonode, "Kernel does not know node for %s\n", id + len); } return ret; } } return NO_IO_AFFINITY; }