[dpdk-dev] [RFC 4/7] eal/linuxapp: support SoC infra in linuxapp

[Jan Viktorin <viktorin@rehivetech.com>]

Provide Linux-specific discovery routines. The discovery reads the
/sys/bus/platform/devices/*/uevent file for each device. If the uevent
file contains OF_FULLNAME entry (path in the Device Tree) and a list of
OF_COMPATIBLE_# entries, it is considered as a SoC device and inserted
into the soc_device_list.

We do not care about the mem_resources at the moment. We need a proper
Linux Kernel driver to support this. Gathering of the resource information
could be done by parsing reg properties in the Device Tree.

There is a possible pitfall here, if there is a device depending on another
device (eg. an EMAC with a separate DMA engine), we cannot treat it as a
single device as the relation between whose might not be described in a
standardized way. So the drivers of the particular devices must take care of
this themselfs.

Signed-off-by: Jan Viktorin <viktorin@rehivetech.com>
---
 lib/librte_eal/linuxapp/eal/Makefile  |   2 +
 lib/librte_eal/linuxapp/eal/eal_soc.c | 394 ++++++++++++++++++++++++++++++++++
 2 files changed, 396 insertions(+)
 create mode 100644 lib/librte_eal/linuxapp/eal/eal_soc.c

diff --git a/lib/librte_eal/linuxapp/eal/Makefile b/lib/librte_eal/linuxapp/eal/Makefile
index f2ed696..11e2dc8 100644
--- a/lib/librte_eal/linuxapp/eal/Makefile
+++ b/lib/librte_eal/linuxapp/eal/Makefile
@@ -60,6 +60,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_pci.c
 SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_pci_uio.c
 SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_pci_vfio.c
 SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_pci_vfio_mp_sync.c
+SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_soc.c
 SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_debug.c
 SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_lcore.c
 SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_timer.c
@@ -105,6 +106,7 @@ CFLAGS_eal_hugepage_info.o := -D_GNU_SOURCE
 CFLAGS_eal_pci.o := -D_GNU_SOURCE
 CFLAGS_eal_pci_uio.o := -D_GNU_SOURCE
 CFLAGS_eal_pci_vfio.o := -D_GNU_SOURCE
+CFLAGS_eal_soc.o := -D_GNU_SOURCE
 CFLAGS_eal_common_whitelist.o := -D_GNU_SOURCE
 CFLAGS_eal_common_options.o := -D_GNU_SOURCE
 CFLAGS_eal_common_thread.o := -D_GNU_SOURCE
diff --git a/lib/librte_eal/linuxapp/eal/eal_soc.c b/lib/librte_eal/linuxapp/eal/eal_soc.c
new file mode 100644
index 0000000..be0e44d
--- /dev/null
+++ b/lib/librte_eal/linuxapp/eal/eal_soc.c
@@ -0,0 +1,394 @@
+/*-
+ *   BSD LICENSE
+ *
+ *   Copyright(c) 2016 RehiveTech. All rights reserved.
+ *   All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions
+ *   are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in
+ *       the documentation and/or other materials provided with the
+ *       distribution.
+ *     * Neither the name of Intel Corporation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <string.h>
+#include <dirent.h>
+#include <sys/stat.h>
+
+#include <rte_log.h>
+#include <rte_pci.h>
+#include <rte_eal_memconfig.h>
+#include <rte_malloc.h>
+#include <rte_devargs.h>
+#include <rte_memcpy.h>
+
+#include "eal_filesystem.h"
+#include "eal_private.h"
+#include "eal_pci_init.h"
+
+int
+soc_map_device(struct rte_soc_device *dev)
+{
+	int rc = -1;
+
+	switch (dev->kdrv) {
+	case RTE_SOC_KDRV_NONE:
+		rc = 0;
+		break;
+	default:
+		RTE_LOG(DEBUG, EAL,
+			"  Not managed by a supported kernel driver, skipped\n");
+		rc = 1;
+		break;
+	}
+
+	return rc;
+}
+
+void
+soc_unmap_device(struct rte_soc_device *dev)
+{
+	switch (dev->kdrv) {
+	case RTE_SOC_KDRV_NONE:
+		break;
+	default:
+		RTE_LOG(DEBUG, EAL,
+			"  Not managed by a supported kernel driver, skipped\n");
+		break;
+	}
+}
+
+static char *
+linecpy(char *dst, const char *line, size_t max)
+{
+	size_t len = 0;
+
+	while (line[len] && line[len] != '\n')
+		len += 1;
+
+	return (char *) memcpy(dst, line, len > max? max : len);
+}
+
+static char *
+linedup(const char *line)
+{
+	size_t len = 0;
+	char *s;
+
+	while (line[len] && line[len] != '\n')
+		len += 1;
+
+	s = malloc(len + 1);
+	if (s == NULL)
+		return NULL;
+
+	memcpy(s, line, len);
+	s[len] = '\0';
+	return s;
+}
+
+static const char *
+uevent_find_entry(const char *start, const char *end,
+		const char *prefix, const char *context)
+{
+	const size_t len = strlen(prefix);
+	const char *p = start;
+
+	while (strncmp(prefix, p, len)) {
+		while (p < end && *p != '\n') {
+			p += 1;
+		}
+
+		if (p >= end) {
+			RTE_LOG(WARNING, EAL,
+				"%s(): missing uevent entry %s (%s)\n",
+				__func__, prefix, context);
+			return NULL;
+		}
+		else {
+			p += 1; /* skip end-of-line */
+		}
+	}
+
+	if (p + len < end)
+		return p + len;
+	else {
+		RTE_LOG(WARNING, EAL,
+			"%s(): missing value for uevent entry %s (%s)\n",
+			__func__, prefix, context);
+		return NULL;
+	}
+}
+
+static int
+soc_device_from_uevent(struct rte_soc_device *dev, const char *uevent)
+{
+	FILE *f;
+	struct stat st;
+	char *buf;
+	char *end;
+	char *err;
+	const char *entry;
+	unsigned long i;
+	unsigned long count;
+
+	if ((f = fopen(uevent, "r")) == NULL) {
+		RTE_LOG(ERR, EAL, "%s(): cannot open sysfs file uevent\n",
+			__func__);
+		return -1;
+	}
+
+	if (fstat(fileno(f), &st) < 0) {
+		RTE_LOG(ERR, EAL, "%s(): cannot stat sysfs file uevent (%s)\n",
+			__func__, strerror(errno));
+		goto fail_fclose;
+	}
+
+	if (st.st_size <= 0) {
+		RTE_LOG(ERR, EAL, "%s(): sysfs file uevent seems to be empty\n",
+			__func__);
+		goto fail_fclose_skip;
+	}
+
+	buf = malloc(st.st_size + 1);
+	if (buf == NULL) {
+		RTE_LOG(ERR, EAL, "%s(): failed to alloc memory\n", __func__);
+		goto fail_fclose;
+	}
+
+	if (fread(buf, 1, st.st_size, f) == 0) {
+		RTE_LOG(ERR, EAL, "%s(): cannot read sysfs file uevent\n",
+			__func__);
+		goto fail_free_buf;
+	}
+	buf[st.st_size] = '\0';
+	end = buf + st.st_size;
+
+	entry = uevent_find_entry(buf, end, "OF_FULLNAME=", uevent);
+	if (entry == NULL)
+		goto fail_free_buf_skip;
+
+	linecpy((char *) dev->addr.devtree_path, entry,
+		sizeof(dev->addr.devtree_path));
+
+	RTE_LOG(DEBUG, EAL, "%s(): OF_FULLNAME=%s\n", __func__,
+			dev->addr.devtree_path);
+
+	entry = uevent_find_entry(buf, end, "OF_COMPATIBLE_N=", uevent);
+	if (entry == NULL)
+		goto fail_free_buf_skip; /* reported from uevent_find_entry */
+
+	count = strtoul(entry, &err, 0);
+	if (err == NULL) {
+		RTE_LOG(ERR, EAL, "%s(): failed to parse OF_COMPATIBLE_N\n",
+			__func__);
+		goto fail_free_buf;
+	}
+
+	RTE_LOG(DEBUG, EAL, "%s(): OF_COMPATIBLE_N=%lu\n", __func__, count);
+
+	dev->id.compatible = calloc(count + 1, sizeof(*dev->id.compatible));
+	if (dev->id.compatible == NULL) {
+		RTE_LOG(ERR, EAL, "%s(): failed to alloc memory\n",
+			__func__);
+		goto fail_free_buf;
+	}
+
+	if (count > 9999) /* FIXME: better way? */
+		rte_exit(EXIT_FAILURE, "Strange count of OF_COMPATIBLE entries"
+				"in sysfs uevent\n");
+
+	for (i = 0; i < count; ++i) {
+		char prefix[strlen("OF_COMPATIBLE_NNNN=")];
+		snprintf(prefix, sizeof(prefix), "OF_COMPATIBLE_%lu=", i);
+
+		entry = uevent_find_entry(buf, end, prefix, uevent);
+		if (entry == NULL) {
+			while (i-- > 0)
+				free(dev->id.compatible[i]);
+			goto fail_id_compatible;
+		}
+
+		dev->id.compatible[i] = linedup(entry);
+		RTE_LOG(DEBUG, EAL, "%s(): %s%s\n", __func__, prefix,
+				dev->id.compatible[i]);
+		if (dev->id.compatible[i] == NULL) {
+			RTE_LOG(ERR, EAL, "%s(): failed to alloc memory\n",
+				__func__);
+
+			while (i-- > 0)
+				free(dev->id.compatible[i]);
+			goto fail_id_compatible;
+		}
+	}
+
+	dev->id.compatible[count] = NULL;
+	return 0;
+
+fail_id_compatible:
+	free(dev->id.compatible);
+fail_free_buf:
+	free(buf);
+fail_fclose:
+	fclose(f);
+	return -1;
+fail_free_buf_skip:
+	free(buf);
+fail_fclose_skip:
+	fclose(f);
+	return 1;
+}
+
+static void
+soc_device_uevent_free(struct rte_soc_device *dev)
+{
+	if (!dev)
+		return;
+
+	if (dev->id.compatible) {
+		int i;
+
+		for (i = 0; dev->id.compatible[i]; ++i)
+			free(dev->id.compatible[i]);
+
+		free(dev->id.compatible);
+	}
+}
+
+static void
+soc_device_free(struct rte_soc_device *dev)
+{
+	soc_device_uevent_free(dev);
+	free(dev);
+}
+
+static int
+soc_scan_one(const char *dirname)
+{
+	char filename[PATH_MAX];
+	struct rte_soc_device *dev;
+	unsigned long tmp;
+	int rc;
+
+	dev = calloc(1, sizeof(*dev));
+	if (dev == NULL)
+		return -1;
+
+	snprintf(filename, sizeof(filename), "%s/numa_node", dirname);
+	if (access(filename, R_OK) != 0) {
+		/* no NUMA support */
+		dev->numa_node = 0;
+	} else {
+		if (eal_parse_sysfs_value(filename, &tmp) < 0) {
+			free(dev);
+			return -1;
+		}
+		dev->numa_node = tmp;
+	}
+
+	snprintf(filename, sizeof(filename), "%s/uevent", dirname);
+	rc = soc_device_from_uevent(dev, filename);
+	if (rc) {
+		free(dev);
+		return rc;
+	}
+
+	dev->driver = NULL;
+	dev->kdrv = RTE_SOC_KDRV_NONE;
+
+	if (TAILQ_EMPTY(&soc_device_list)) {
+		TAILQ_INSERT_TAIL(&soc_device_list, dev, next);
+	} else {
+		struct rte_soc_device *dev2;
+		int rc;
+
+		TAILQ_FOREACH(dev2, &soc_device_list, next) {
+			rc = rte_eal_compare_soc_addr(&dev->addr, &dev2->addr);
+			if (rc > 0)
+				continue;
+
+			if (rc < 0) {
+				TAILQ_INSERT_BEFORE(dev2, dev, next);
+			} else { /* already exists */
+				dev2->kdrv = dev->kdrv;
+				memmove(dev2->mem_resource, dev->mem_resource,
+						sizeof(dev->mem_resource));
+				soc_device_free(dev);
+			}
+			return 0;
+		}
+		TAILQ_INSERT_TAIL(&soc_device_list, dev, next);
+	}
+
+	return 0;
+}
+
+int
+rte_eal_soc_scan(void)
+{
+	struct dirent *e;
+	DIR *dir;
+	char dirname[PATH_MAX];
+
+	dir = opendir(SYSFS_SOC_DEVICES);
+	if (dir == NULL) {
+		RTE_LOG(ERR, EAL, "%s(): opendir failed: %s\n",
+			__func__, strerror(errno));
+		return -1;
+	}
+
+	while ((e = readdir(dir)) != NULL) {
+		if (e->d_name[0] == '.')
+			continue;
+
+		snprintf(dirname, sizeof(dirname), "%s/%s", SYSFS_SOC_DEVICES,
+				e->d_name);
+		if (soc_scan_one(dirname) < 0)
+			goto error;
+	}
+
+	closedir(dir);
+	return 0;
+
+error:
+	closedir(dir);
+	return -1;
+}
+
+int
+rte_eal_soc_init(void)
+{
+	TAILQ_INIT(&soc_driver_list);
+	TAILQ_INIT(&soc_device_list);
+
+	if (internal_config.no_soc)
+		return 0;
+
+	if (rte_eal_soc_scan() < 0) {
+		RTE_LOG(ERR, EAL, "%s(): Failed to scan for SoC devices\n",
+			__func__);
+		return -1;
+	}
+
+	return 0;
+}
-- 
2.6.3