d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

pmdinfogen: add buildtools and pmdinfogen utility

Browse Source 
pmdinfogen is a tool used to parse object files and build json strings for
use in later determining hardware support in a dso or application binary.
pmdinfo looks for the non-exported symbol names this_pmd_name<n> and
this_pmd_tbl<n> (where n is a integer counter).  It records the name of
each of these tuples, using the later to find the symbolic name of the
pci_table for physical devices that the object supports.  With this
information, it outputs a C file with a single line of the form:

static char *<pmd_name>_driver_info[] __attribute__((used)) = " \
	PMD_DRIVER_INFO=<json string>";

Where <pmd_name> is the arbitrary name of the pmd, and <json_string> is the
json encoded string that hold relevant pmd information, including the pmd
name, type and optional array of pci device/vendor ids that the driver
supports.

This c file is suitable for compiling to object code, then relocatably
linking into the parent file from which the C was generated.  This creates
an entry in the string table of the object that can inform a later tool
about hardware support.

Signed-off-by: Neil Horman <nhorman@tuxdriver.com>
Acked-by: Panu Matilainen <pmatilai@redhat.com>
Acked-by: Remy Horton <remy.horton@intel.com>
This commit is contained in:
Neil Horman 2016-06-17 14:46:20 -04:00 committed by Thomas Monjalon
parent 26622cbe1b
commit 98b0fdb0ff
8 changed files with 653 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
GNUmakefile
View File

@ -40,6 +40,6 @@ export RTE_SDK
# directory list
#
ROOTDIRS-y := lib drivers app
ROOTDIRS-y := buildtools lib drivers app
include $(RTE_SDK)/mk/rte.sdkroot.mk

36
buildtools/Makefile Normal file
View File

@ -0,0 +1,36 @@
# BSD LICENSE
#
# Copyright(c) 2016 Neil Horman. 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 $(RTE_SDK)/mk/rte.vars.mk
DIRS-y += pmdinfogen
include $(RTE_SDK)/mk/rte.subdir.mk

49
buildtools/pmdinfogen/Makefile Normal file
View File

@ -0,0 +1,49 @@
# BSD LICENSE
#
# Copyright(c) 2016 Neil Horman. 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 $(RTE_SDK)/mk/rte.vars.mk
#
# library name
#
HOSTAPP = pmdinfogen
#
# all sources are stored in SRCS-y
#
SRCS-y += pmdinfogen.c
HOST_EXTRA_CFLAGS += -g -I${RTE_OUTPUT}/include
DEPDIRS-y += lib/librte_eal
include $(RTE_SDK)/mk/rte.hostapp.mk

439
buildtools/pmdinfogen/pmdinfogen.c Normal file
View File

@ -0,0 +1,439 @@
/* Postprocess pmd object files to export hw support
*
* Copyright 2016 Neil Horman <nhorman@tuxdriver.com>
* Based in part on modpost.c from the linux kernel
*
* This software may be used and distributed according to the terms
* of the GNU General Public License V2, incorporated herein by reference.
*
*/
#define _GNU_SOURCE
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <limits.h>
#include <stdbool.h>
#include <errno.h>
#include "pmdinfogen.h"
#ifdef RTE_ARCH_64
#define ADDR_SIZE 64
#else
#define ADDR_SIZE 32
#endif
static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
{
if (sym)
return elf->strtab + sym->st_name;
else
return "(unknown)";
}
void *grab_file(const char *filename, unsigned long *size)
{
struct stat st;
void *map = MAP_FAILED;
int fd;
fd = open(filename, O_RDONLY);
if (fd < 0)
return NULL;
if (fstat(fd, &st))
goto failed;
*size = st.st_size;
map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
failed:
close(fd);
if (map == MAP_FAILED)
return NULL;
return map;
}
/**
* Return a copy of the next line in a mmap'ed file.
* spaces in the beginning of the line is trimmed away.
* Return a pointer to a static buffer.
**/
void release_file(void *file, unsigned long size)
{
munmap(file, size);
}
static void *get_sym_value(struct elf_info *info, const Elf_Sym *sym)
{
void *ptr = (void *)info->hdr + info->sechdrs[sym->st_shndx].sh_offset;
return (void *)(ptr + sym->st_value);
}
static Elf_Sym *find_sym_in_symtab(struct elf_info *info,
const char *name, Elf_Sym *last)
{
Elf_Sym *idx;
if (last)
idx = last+1;
else
idx = info->symtab_start;
for (; idx < info->symtab_stop; idx++) {
const char *n = sym_name(info, idx);
if (!strncmp(n, name, strlen(name)))
return idx;
}
return NULL;
}
static int parse_elf(struct elf_info *info, const char *filename)
{
unsigned int i;
Elf_Ehdr *hdr;
Elf_Shdr *sechdrs;
Elf_Sym *sym;
const char *secstrings;
int endian;
unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U;
hdr = grab_file(filename, &info->size);
if (!hdr) {
perror(filename);
exit(1);
}
info->hdr = hdr;
if (info->size < sizeof(*hdr)) {
/* file too small, assume this is an empty .o file */
return 0;
}
/* Is this a valid ELF file? */
if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
(hdr->e_ident[EI_MAG1] != ELFMAG1) ||
(hdr->e_ident[EI_MAG2] != ELFMAG2) ||
(hdr->e_ident[EI_MAG3] != ELFMAG3)) {
/* Not an ELF file - silently ignore it */
return 0;
}
if (!hdr->e_ident[EI_DATA]) {
/* Unknown endian */
return 0;
}
endian = hdr->e_ident[EI_DATA];
/* Fix endianness in ELF header */
hdr->e_type = TO_NATIVE(endian, 16, hdr->e_type);
hdr->e_machine = TO_NATIVE(endian, 16, hdr->e_machine);
hdr->e_version = TO_NATIVE(endian, 32, hdr->e_version);
hdr->e_entry = TO_NATIVE(endian, ADDR_SIZE, hdr->e_entry);
hdr->e_phoff = TO_NATIVE(endian, ADDR_SIZE, hdr->e_phoff);
hdr->e_shoff = TO_NATIVE(endian, ADDR_SIZE, hdr->e_shoff);
hdr->e_flags = TO_NATIVE(endian, 32, hdr->e_flags);
hdr->e_ehsize = TO_NATIVE(endian, 16, hdr->e_ehsize);
hdr->e_phentsize = TO_NATIVE(endian, 16, hdr->e_phentsize);
hdr->e_phnum = TO_NATIVE(endian, 16, hdr->e_phnum);
hdr->e_shentsize = TO_NATIVE(endian, 16, hdr->e_shentsize);
hdr->e_shnum = TO_NATIVE(endian, 16, hdr->e_shnum);
hdr->e_shstrndx = TO_NATIVE(endian, 16, hdr->e_shstrndx);
sechdrs = (void *)hdr + hdr->e_shoff;
info->sechdrs = sechdrs;
/* Check if file offset is correct */
if (hdr->e_shoff > info->size) {
fprintf(stderr, "section header offset=%lu in file '%s' "
"is bigger than filesize=%lu\n",
(unsigned long)hdr->e_shoff,
filename, info->size);
return 0;
}
if (hdr->e_shnum == SHN_UNDEF) {
/*
* There are more than 64k sections,
* read count from .sh_size.
*/
info->num_sections = TO_NATIVE(endian, 32, sechdrs[0].sh_size);
} else {
info->num_sections = hdr->e_shnum;
}
if (hdr->e_shstrndx == SHN_XINDEX)
info->secindex_strings =
TO_NATIVE(endian, 32, sechdrs[0].sh_link);
else
info->secindex_strings = hdr->e_shstrndx;
/* Fix endianness in section headers */
for (i = 0; i < info->num_sections; i++) {
sechdrs[i].sh_name =
TO_NATIVE(endian, 32, sechdrs[i].sh_name);
sechdrs[i].sh_type =
TO_NATIVE(endian, 32, sechdrs[i].sh_type);
sechdrs[i].sh_flags =
TO_NATIVE(endian, 32, sechdrs[i].sh_flags);
sechdrs[i].sh_addr =
TO_NATIVE(endian, ADDR_SIZE, sechdrs[i].sh_addr);
sechdrs[i].sh_offset =
TO_NATIVE(endian, ADDR_SIZE, sechdrs[i].sh_offset);
sechdrs[i].sh_size =
TO_NATIVE(endian, 32, sechdrs[i].sh_size);
sechdrs[i].sh_link =
TO_NATIVE(endian, 32, sechdrs[i].sh_link);
sechdrs[i].sh_info =
TO_NATIVE(endian, 32, sechdrs[i].sh_info);
sechdrs[i].sh_addralign =
TO_NATIVE(endian, ADDR_SIZE, sechdrs[i].sh_addralign);
sechdrs[i].sh_entsize =
TO_NATIVE(endian, ADDR_SIZE, sechdrs[i].sh_entsize);
}
/* Find symbol table. */
secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset;
for (i = 1; i < info->num_sections; i++) {
int nobits = sechdrs[i].sh_type == SHT_NOBITS;
if (!nobits && sechdrs[i].sh_offset > info->size) {
fprintf(stderr, "%s is truncated. "
"sechdrs[i].sh_offset=%lu > sizeof(*hrd)=%zu\n",
filename, (unsigned long)sechdrs[i].sh_offset,
sizeof(*hdr));
return 0;
}
if (sechdrs[i].sh_type == SHT_SYMTAB) {
unsigned int sh_link_idx;
symtab_idx = i;
info->symtab_start = (void *)hdr +
sechdrs[i].sh_offset;
info->symtab_stop = (void *)hdr +
sechdrs[i].sh_offset + sechdrs[i].sh_size;
sh_link_idx = sechdrs[i].sh_link;
info->strtab = (void *)hdr +
sechdrs[sh_link_idx].sh_offset;
}
/* 32bit section no. table? ("more than 64k sections") */
if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) {
symtab_shndx_idx = i;
info->symtab_shndx_start = (void *)hdr +
sechdrs[i].sh_offset;
info->symtab_shndx_stop = (void *)hdr +
sechdrs[i].sh_offset + sechdrs[i].sh_size;
}
}
if (!info->symtab_start)
fprintf(stderr, "%s has no symtab?\n", filename);
/* Fix endianness in symbols */
for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
sym->st_shndx = TO_NATIVE(endian, 16, sym->st_shndx);
sym->st_name = TO_NATIVE(endian, 32, sym->st_name);
sym->st_value = TO_NATIVE(endian, ADDR_SIZE, sym->st_value);
sym->st_size = TO_NATIVE(endian, ADDR_SIZE, sym->st_size);
}
if (symtab_shndx_idx != ~0U) {
Elf32_Word *p;
if (symtab_idx != sechdrs[symtab_shndx_idx].sh_link)
fprintf(stderr,
"%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n",
filename, sechdrs[symtab_shndx_idx].sh_link,
symtab_idx);
/* Fix endianness */
for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop;
p++)
*p = TO_NATIVE(endian, 32, *p);
}
return 1;
}
static void parse_elf_finish(struct elf_info *info)
{
struct pmd_driver *tmp, *idx = info->drivers;
release_file(info->hdr, info->size);
while (idx) {
tmp = idx->next;
free(idx);
idx = tmp;
}
}
static const char *sec_name(struct elf_info *elf, int secindex)
{
Elf_Shdr *sechdrs = elf->sechdrs;
return (void *)elf->hdr +
elf->sechdrs[elf->secindex_strings].sh_offset +
sechdrs[secindex].sh_name;
}
static int get_symbol_index(struct elf_info *info, Elf_Sym *sym)
{
const char *name = sym_name(info, sym);
const char *idx;
idx = name;
while (idx) {
if (isdigit(*idx))
return atoi(idx);
idx++;
}
return -1;
}
struct opt_tag {
const char *suffix;
const char *json_id;
};
static const struct opt_tag opt_tags[] = {
{"_param_string_export", "params"},
};
static int complete_pmd_entry(struct elf_info *info, struct pmd_driver *drv)
{
const char *tname;
int i;
char tmpsymname[128];
Elf_Sym *tmpsym;
drv->name = get_sym_value(info, drv->name_sym);
for (i = 0; i < PMD_OPT_MAX; i++) {
memset(tmpsymname, 0, 128);
sprintf(tmpsymname, "__%s%s", drv->name, opt_tags[i].suffix);
tmpsym = find_sym_in_symtab(info, tmpsymname, NULL);
if (!tmpsym)
continue;
drv->opt_vals[i] = get_sym_value(info, tmpsym);
}
memset(tmpsymname, 0, 128);
sprintf(tmpsymname, "__%s_pci_tbl_export", drv->name);
tmpsym = find_sym_in_symtab(info, tmpsymname, NULL);
/*
* If this returns NULL, then this is a PMD_VDEV, because
* it has no pci table reference
*/
if (!tmpsym) {
drv->pci_tbl = NULL;
return 0;
}
tname = get_sym_value(info, tmpsym);
tmpsym = find_sym_in_symtab(info, tname, NULL);
if (!tmpsym)
return -ENOENT;
drv->pci_tbl = (struct rte_pci_id *)get_sym_value(info, tmpsym);
if (!drv->pci_tbl)
return -ENOENT;
return 0;
}
static int locate_pmd_entries(struct elf_info *info)
{
Elf_Sym *last = NULL;
struct pmd_driver *new;
info->drivers = NULL;
do {
new = calloc(sizeof(struct pmd_driver), 1);
new->name_sym = find_sym_in_symtab(info, "this_pmd_name", last);
last = new->name_sym;
if (!new->name_sym)
free(new);
else {
if (complete_pmd_entry(info, new)) {
fprintf(stderr,
"Failed to complete pmd entry\n");
free(new);
} else {
new->next = info->drivers;
info->drivers = new;
}
}
} while (last);
}
static void output_pmd_info_string(struct elf_info *info, char *outfile)
{
FILE *ofd;
struct pmd_driver *drv;
struct rte_pci_id *pci_ids;
int idx = 0;
ofd = fopen(outfile, "w+");
if (!ofd) {
fprintf(stderr, "Unable to open output file\n");
return;
}
drv = info->drivers;
while (drv) {
fprintf(ofd, "const char %s_pmd_info[] __attribute__((used)) = "
"\"PMD_INFO_STRING= {",
drv->name);
fprintf(ofd, "\\\"name\\\" : \\\"%s\\\", ", drv->name);
for (idx = 0; idx < PMD_OPT_MAX; idx++) {
if (drv->opt_vals[idx])
fprintf(ofd, "\\\"%s\\\" : \\\"%s\\\", ",
opt_tags[idx].json_id,
drv->opt_vals[idx]);
}
pci_ids = drv->pci_tbl;
fprintf(ofd, "\\\"pci_ids\\\" : [");
while (pci_ids && pci_ids->device_id) {
fprintf(ofd, "[%d, %d, %d, %d]",
pci_ids->vendor_id, pci_ids->device_id,
pci_ids->subsystem_vendor_id,
pci_ids->subsystem_device_id);
pci_ids++;
if (pci_ids->device_id)
fprintf(ofd, ",");
else
fprintf(ofd, " ");
}
fprintf(ofd, "]}\";");
drv = drv->next;
}
fclose(ofd);
}
int main(int argc, char **argv)
{
struct elf_info info;
int rc = 1;
if (argc < 3) {
fprintf(stderr,
"usage: pmdinfo <object file> <c output file>\n");
exit(127);
}
parse_elf(&info, argv[1]);
locate_pmd_entries(&info);
if (info.drivers) {
output_pmd_info_string(&info, argv[2]);
rc = 0;
} else {
fprintf(stderr, "No drivers registered\n");
}
parse_elf_finish(&info);
exit(rc);
}

120
buildtools/pmdinfogen/pmdinfogen.h Normal file
View File

@ -0,0 +1,120 @@
/* Postprocess pmd object files to export hw support
*
* Copyright 2016 Neil Horman <nhorman@tuxdriver.com>
* Based in part on modpost.c from the linux kernel
*
* This software may be used and distributed according to the terms
* of the GNU General Public License V2, incorporated herein by reference.
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <elf.h>
#include <rte_config.h>
#include <rte_pci.h>
#include <rte_byteorder.h>
/* On BSD-alike OSes elf.h defines these according to host's word size */
#undef ELF_ST_BIND
#undef ELF_ST_TYPE
#undef ELF_R_SYM
#undef ELF_R_TYPE
/*
* Define ELF64_* to ELF_*, the latter being defined in both 32 and 64 bit
* flavors in elf.h. This makes our code a bit more generic between arches
* and allows us to support 32 bit code in the future should we ever want to
*/
#ifdef RTE_ARCH_64
#define Elf_Ehdr Elf64_Ehdr
#define Elf_Shdr Elf64_Shdr
#define Elf_Sym Elf64_Sym
#define Elf_Addr Elf64_Addr
#define Elf_Sword Elf64_Sxword
#define Elf_Section Elf64_Half
#define ELF_ST_BIND ELF64_ST_BIND
#define ELF_ST_TYPE ELF64_ST_TYPE
#define Elf_Rel Elf64_Rel
#define Elf_Rela Elf64_Rela
#define ELF_R_SYM ELF64_R_SYM
#define ELF_R_TYPE ELF64_R_TYPE
#else
#define Elf_Ehdr Elf32_Ehdr
#define Elf_Shdr Elf32_Shdr
#define Elf_Sym Elf32_Sym
#define Elf_Addr Elf32_Addr
#define Elf_Sword Elf32_Sxword
#define Elf_Section Elf32_Half
#define ELF_ST_BIND ELF32_ST_BIND
#define ELF_ST_TYPE ELF32_ST_TYPE
#define Elf_Rel Elf32_Rel
#define Elf_Rela Elf32_Rela
#define ELF_R_SYM ELF32_R_SYM
#define ELF_R_TYPE ELF32_R_TYPE
#endif
/*
* Note, it seems odd that we have both a CONVERT_NATIVE and a TO_NATIVE macro
* below. We do this because the values passed to TO_NATIVE may themselves be
* macros and need both macros here to get expanded. Specifically its the width
* variable we are concerned with, because it needs to get expanded prior to
* string concatenation
*/
#define CONVERT_NATIVE(fend, width, x) ({ \
typeof(x) ___x; \
if ((fend) == ELFDATA2LSB) \
___x = rte_le_to_cpu_##width(x); \
else \
___x = rte_be_to_cpu_##width(x); \
___x; \
})
#define TO_NATIVE(fend, width, x) CONVERT_NATIVE(fend, width, x)
enum opt_params {
PMD_PARAM_STRING = 0,
PMD_OPT_MAX
};
struct pmd_driver {
Elf_Sym *name_sym;
const char *name;
struct rte_pci_id *pci_tbl;
struct pmd_driver *next;
const char *opt_vals[PMD_OPT_MAX];
};
struct elf_info {
unsigned long size;
Elf_Ehdr *hdr;
Elf_Shdr *sechdrs;
Elf_Sym *symtab_start;
Elf_Sym *symtab_stop;
char *strtab;
/* support for 32bit section numbers */
unsigned int num_sections; /* max_secindex + 1 */
unsigned int secindex_strings;
/* if Nth symbol table entry has .st_shndx = SHN_XINDEX,
* take shndx from symtab_shndx_start[N] instead
*/
Elf32_Word *symtab_shndx_start;
Elf32_Word *symtab_shndx_stop;
struct pmd_driver *drivers;
};

8
mk/rte.hostapp.mk
View File

@ -41,7 +41,7 @@ include $(RTE_SDK)/mk/internal/rte.depdirs-pre.mk
VPATH += $(SRCDIR)
_BUILD = $(HOSTAPP)
_INSTALL = $(INSTALL-FILES-y) $(SYMLINK-FILES-y) $(RTE_OUTPUT)/hostapp/$(HOSTAPP)
_INSTALL = $(INSTALL-FILES-y) $(SYMLINK-FILES-y) $(RTE_OUTPUT)/app/$(HOSTAPP)
_CLEAN = doclean
.PHONY: all
@ -95,10 +95,10 @@ $(HOSTAPP): $(OBJS-y) $(LDLIBS_FILES) FORCE
#
# install app in $(RTE_OUTPUT)/hostapp
#
$(RTE_OUTPUT)/hostapp/$(HOSTAPP): $(HOSTAPP)
$(RTE_OUTPUT)/app/$(HOSTAPP): $(HOSTAPP)
@echo " INSTALL-HOSTAPP $(HOSTAPP)"
@[ -d $(RTE_OUTPUT)/hostapp ] || mkdir -p $(RTE_OUTPUT)/hostapp
$(Q)cp -f $(HOSTAPP) $(RTE_OUTPUT)/hostapp
@[ -d $(RTE_OUTPUT)/app ] || mkdir -p $(RTE_OUTPUT)/app
$(Q)cp -f $(HOSTAPP) $(RTE_OUTPUT)/app
#
# Clean all generated files

3
mk/rte.sdkbuild.mk
View File

@ -64,7 +64,8 @@ build: $(ROOTDIRS-y)
clean: $(CLEANDIRS)
@rm -rf $(RTE_OUTPUT)/include $(RTE_OUTPUT)/app \
$(RTE_OUTPUT)/hostapp $(RTE_OUTPUT)/lib \
$(RTE_OUTPUT)/hostlib $(RTE_OUTPUT)/kmod
$(RTE_OUTPUT)/hostlib $(RTE_OUTPUT)/kmod \
$(RTE_OUTPUT)/buildtools
@[ -d $(RTE_OUTPUT)/include ] || mkdir -p $(RTE_OUTPUT)/include
@$(RTE_SDK)/scripts/gen-config-h.sh $(RTE_OUTPUT)/.config \
> $(RTE_OUTPUT)/include/rte_config.h

2
mk/rte.sdkinstall.mk
View File

@ -126,6 +126,8 @@ install-runtime:
$(Q)$(call rte_mkdir, $(DESTDIR)$(sbindir))
$(Q)$(call rte_symlink, $(DESTDIR)$(datadir)/tools/dpdk_nic_bind.py, \
$(DESTDIR)$(sbindir)/dpdk_nic_bind)
$(Q)$(call rte_symlink, $(DESTDIR)$(bindir)/pmdinfogen, \
$(DESTDIR)$(bindir)/dpdk_pmdinfogen)
install-kmod:
ifneq ($(wildcard $O/kmod/*),)