2017-12-19 15:49:03 +00:00
|
|
|
/* SPDX-License-Identifier: BSD-3-Clause
|
eal: add channel for multi-process communication
Previouly, there are three channels for multi-process
(i.e., primary/secondary) communication.
1. Config-file based channel, in which, the primary process writes
info into a pre-defined config file, and the secondary process
reads the info out.
2. vfio submodule has its own channel based on unix socket for the
secondary process to get container fd and group fd from the
primary process.
3. pdump submodule also has its own channel based on unix socket for
packet dump.
It'd be good to have a generic communication channel for multi-process
communication to accommodate the requirements including:
a. Secondary wants to send info to primary, for example, secondary
would like to send request (about some specific vdev to primary).
b. Sending info at any time, instead of just initialization time.
c. Share FDs with the other side, for vdev like vhost, related FDs
(memory region, kick) should be shared.
d. A send message request needs the other side to response immediately.
This patch proposes to create a communication channel, based on datagram
unix socket, for above requirements. Each process will block on a unix
socket waiting for messages from the peers.
Three new APIs are added:
1. rte_eal_mp_action_register() is used to register an action,
indexed by a string, when a component at receiver side would like
to response the messages from the peer processe.
2. rte_eal_mp_action_unregister() is used to unregister the action
if the calling component does not want to response the messages.
3. rte_eal_mp_sendmsg() is used to send a message, and returns
immediately. If there are n secondary processes, the primary
process will send n messages.
Suggested-by: Konstantin Ananyev <konstantin.ananyev@intel.com>
Signed-off-by: Jianfeng Tan <jianfeng.tan@intel.com>
Reviewed-by: Anatoly Burakov <anatoly.burakov@intel.com>
Acked-by: Konstantin Ananyev <konstantin.ananyev@intel.com>
2018-01-30 06:58:08 +00:00
|
|
|
* Copyright(c) 2010-2018 Intel Corporation
|
2014-02-10 11:49:10 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @file
|
|
|
|
* Stores functions and path defines for files and directories
|
|
|
|
* on the filesystem for Linux, that are used by the Linux EAL.
|
|
|
|
*/
|
|
|
|
|
2014-11-21 15:26:17 +01:00
|
|
|
#ifndef EAL_FILESYSTEM_H
|
|
|
|
#define EAL_FILESYSTEM_H
|
2014-02-10 11:49:10 +00:00
|
|
|
|
|
|
|
/** Path of rte config file. */
|
|
|
|
#define RUNTIME_CONFIG_FMT "%s/.%s_config"
|
2018-04-23 12:14:13 +01:00
|
|
|
#define FBARRAY_FMT "%s/.%s_%s"
|
2014-02-10 11:49:10 +00:00
|
|
|
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <limits.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
|
|
|
#include <rte_string_fns.h>
|
|
|
|
#include "eal_internal_cfg.h"
|
|
|
|
|
|
|
|
static const char *default_config_dir = "/var/run";
|
|
|
|
|
|
|
|
static inline const char *
|
|
|
|
eal_runtime_config_path(void)
|
|
|
|
{
|
|
|
|
static char buffer[PATH_MAX]; /* static so auto-zeroed */
|
|
|
|
const char *directory = default_config_dir;
|
|
|
|
const char *home_dir = getenv("HOME");
|
|
|
|
|
|
|
|
if (getuid() != 0 && home_dir != NULL)
|
|
|
|
directory = home_dir;
|
2014-06-24 11:15:28 -07:00
|
|
|
snprintf(buffer, sizeof(buffer) - 1, RUNTIME_CONFIG_FMT, directory,
|
2014-02-10 11:49:10 +00:00
|
|
|
internal_config.hugefile_prefix);
|
|
|
|
return buffer;
|
|
|
|
}
|
|
|
|
|
eal: add channel for multi-process communication
Previouly, there are three channels for multi-process
(i.e., primary/secondary) communication.
1. Config-file based channel, in which, the primary process writes
info into a pre-defined config file, and the secondary process
reads the info out.
2. vfio submodule has its own channel based on unix socket for the
secondary process to get container fd and group fd from the
primary process.
3. pdump submodule also has its own channel based on unix socket for
packet dump.
It'd be good to have a generic communication channel for multi-process
communication to accommodate the requirements including:
a. Secondary wants to send info to primary, for example, secondary
would like to send request (about some specific vdev to primary).
b. Sending info at any time, instead of just initialization time.
c. Share FDs with the other side, for vdev like vhost, related FDs
(memory region, kick) should be shared.
d. A send message request needs the other side to response immediately.
This patch proposes to create a communication channel, based on datagram
unix socket, for above requirements. Each process will block on a unix
socket waiting for messages from the peers.
Three new APIs are added:
1. rte_eal_mp_action_register() is used to register an action,
indexed by a string, when a component at receiver side would like
to response the messages from the peer processe.
2. rte_eal_mp_action_unregister() is used to unregister the action
if the calling component does not want to response the messages.
3. rte_eal_mp_sendmsg() is used to send a message, and returns
immediately. If there are n secondary processes, the primary
process will send n messages.
Suggested-by: Konstantin Ananyev <konstantin.ananyev@intel.com>
Signed-off-by: Jianfeng Tan <jianfeng.tan@intel.com>
Reviewed-by: Anatoly Burakov <anatoly.burakov@intel.com>
Acked-by: Konstantin Ananyev <konstantin.ananyev@intel.com>
2018-01-30 06:58:08 +00:00
|
|
|
/** Path of primary/secondary communication unix socket file. */
|
|
|
|
#define MP_SOCKET_PATH_FMT "%s/.%s_unix"
|
|
|
|
static inline const char *
|
|
|
|
eal_mp_socket_path(void)
|
|
|
|
{
|
|
|
|
static char buffer[PATH_MAX]; /* static so auto-zeroed */
|
|
|
|
const char *directory = default_config_dir;
|
|
|
|
const char *home_dir = getenv("HOME");
|
|
|
|
|
|
|
|
if (getuid() != 0 && home_dir != NULL)
|
|
|
|
directory = home_dir;
|
|
|
|
snprintf(buffer, sizeof(buffer) - 1, MP_SOCKET_PATH_FMT,
|
|
|
|
directory, internal_config.hugefile_prefix);
|
|
|
|
|
|
|
|
return buffer;
|
|
|
|
}
|
|
|
|
|
eal: add shared indexed file-backed array
rte_fbarray is a simple indexed array stored in shared memory
via mapping files into memory. Rationale for its existence is the
following: since we are going to map memory page-by-page, there
could be quite a lot of memory segments to keep track of (for
smaller page sizes, page count can easily reach thousands). We
can't really make page lists truly dynamic and infinitely expandable,
because that involves reallocating memory (which is a big no-no in
multiprocess). What we can do instead is have a maximum capacity as
something really, really large, and decide at allocation time how
big the array is going to be. We map the entire file into memory,
which makes it possible to use fbarray as shared memory, provided
the structure itself is allocated in shared memory. Per-fbarray
locking is also used to avoid index data races (but not contents
data races - that is up to user application to synchronize).
In addition, in understanding that we will frequently need to scan
this array for free space and iterating over array linearly can
become slow, rte_fbarray provides facilities to index array's
usage. The following use cases are covered:
- find next free/used slot (useful either for adding new elements
to fbarray, or walking the list)
- find starting index for next N free/used slots (useful for when
we want to allocate chunk of VA-contiguous memory composed of
several pages)
- find how many contiguous free/used slots there are, starting
from specified index (useful for when we want to figure out
how many pages we have until next hole in allocated memory, to
speed up some bulk operations where we would otherwise have to
walk the array and add pages one by one)
This is accomplished by storing a usage mask in-memory, right
after the data section of the array, and using some bit-level
magic to figure out the info we need.
Signed-off-by: Anatoly Burakov <anatoly.burakov@intel.com>
Tested-by: Santosh Shukla <santosh.shukla@caviumnetworks.com>
Tested-by: Hemant Agrawal <hemant.agrawal@nxp.com>
Tested-by: Gowrishankar Muthukrishnan <gowrishankar.m@linux.vnet.ibm.com>
2018-04-11 13:30:23 +01:00
|
|
|
static inline const char *
|
|
|
|
eal_get_fbarray_path(char *buffer, size_t buflen, const char *name) {
|
|
|
|
const char *directory = "/tmp";
|
|
|
|
const char *home_dir = getenv("HOME");
|
|
|
|
|
|
|
|
if (getuid() != 0 && home_dir != NULL)
|
|
|
|
directory = home_dir;
|
|
|
|
snprintf(buffer, buflen - 1, FBARRAY_FMT, directory,
|
|
|
|
internal_config.hugefile_prefix, name);
|
|
|
|
return buffer;
|
|
|
|
}
|
|
|
|
|
2014-02-10 11:49:10 +00:00
|
|
|
/** Path of hugepage info file. */
|
|
|
|
#define HUGEPAGE_INFO_FMT "%s/.%s_hugepage_info"
|
|
|
|
|
|
|
|
static inline const char *
|
|
|
|
eal_hugepage_info_path(void)
|
|
|
|
{
|
|
|
|
static char buffer[PATH_MAX]; /* static so auto-zeroed */
|
|
|
|
const char *directory = default_config_dir;
|
|
|
|
const char *home_dir = getenv("HOME");
|
|
|
|
|
|
|
|
if (getuid() != 0 && home_dir != NULL)
|
|
|
|
directory = home_dir;
|
2014-06-24 11:15:28 -07:00
|
|
|
snprintf(buffer, sizeof(buffer) - 1, HUGEPAGE_INFO_FMT, directory,
|
2014-02-10 11:49:10 +00:00
|
|
|
internal_config.hugefile_prefix);
|
|
|
|
return buffer;
|
|
|
|
}
|
|
|
|
|
2018-04-11 13:30:33 +01:00
|
|
|
/** Path of hugepage info file. */
|
|
|
|
#define HUGEPAGE_FILE_FMT "%s/.%s_hugepage_file"
|
|
|
|
|
|
|
|
static inline const char *
|
|
|
|
eal_hugepage_file_path(void)
|
|
|
|
{
|
|
|
|
static char buffer[PATH_MAX]; /* static so auto-zeroed */
|
|
|
|
const char *directory = default_config_dir;
|
|
|
|
const char *home_dir = getenv("HOME");
|
|
|
|
|
|
|
|
if (getuid() != 0 && home_dir != NULL)
|
|
|
|
directory = home_dir;
|
|
|
|
snprintf(buffer, sizeof(buffer) - 1, HUGEPAGE_FILE_FMT, directory,
|
|
|
|
internal_config.hugefile_prefix);
|
|
|
|
return buffer;
|
|
|
|
}
|
|
|
|
|
2014-02-10 11:49:10 +00:00
|
|
|
/** String format for hugepage map files. */
|
|
|
|
#define HUGEFILE_FMT "%s/%smap_%d"
|
|
|
|
#define TEMP_HUGEFILE_FMT "%s/%smap_temp_%d"
|
|
|
|
|
|
|
|
static inline const char *
|
|
|
|
eal_get_hugefile_path(char *buffer, size_t buflen, const char *hugedir, int f_id)
|
|
|
|
{
|
2014-06-24 11:15:28 -07:00
|
|
|
snprintf(buffer, buflen, HUGEFILE_FMT, hugedir,
|
2014-02-10 11:49:10 +00:00
|
|
|
internal_config.hugefile_prefix, f_id);
|
|
|
|
buffer[buflen - 1] = '\0';
|
|
|
|
return buffer;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** define the default filename prefix for the %s values above */
|
|
|
|
#define HUGEFILE_PREFIX_DEFAULT "rte"
|
|
|
|
|
|
|
|
/** Function to read a single numeric value from a file on the filesystem.
|
|
|
|
* Used to read information from files on /sys */
|
|
|
|
int eal_parse_sysfs_value(const char *filename, unsigned long *val);
|
|
|
|
|
2014-11-21 15:26:17 +01:00
|
|
|
#endif /* EAL_FILESYSTEM_H */
|