/* If a pidfile has been configured, creates it and stores the running
* process's pid in it. Ensures that the pidfile will be deleted when the
* process exits. */
static void
make_pidfile(void)
{
if (pidfile) {
/* Create pidfile via temporary file, so that observers never see an
* empty pidfile or an unlocked pidfile. */
long int pid = getpid();
char *tmpfile;
int fd;
tmpfile = xasprintf("%s.tmp%ld", pidfile, pid);
fatal_signal_add_file_to_unlink(tmpfile);
fd = open(tmpfile, O_CREAT | O_WRONLY | O_TRUNC, 0666);
if (fd >= 0) {
struct flock lck;
lck.l_type = F_WRLCK;
lck.l_whence = SEEK_SET;
lck.l_start = 0;
lck.l_len = 0;
if (fcntl(fd, F_SETLK, &lck) != -1) {
char *text = xasprintf("%ld\n", pid);
if (write(fd, text, strlen(text)) == strlen(text)) {
fatal_signal_add_file_to_unlink(pidfile);
if (rename(tmpfile, pidfile) < 0) {
VLOG_ERR("failed to rename \"%s\" to \"%s\": %s",
tmpfile, pidfile, strerror(errno));
fatal_signal_remove_file_to_unlink(pidfile);
close(fd);
} else {
/* Keep 'fd' open to retain the lock. */
}
free(text);
} else {
VLOG_ERR("%s: write failed: %s", tmpfile, strerror(errno));
close(fd);
}
} else {
VLOG_ERR("%s: fcntl failed: %s", tmpfile, strerror(errno));
close(fd);
}
} else {
VLOG_ERR("%s: create failed: %s", tmpfile, strerror(errno));
}
fatal_signal_remove_file_to_unlink(tmpfile);
free(tmpfile);
}
free(pidfile);
pidfile = NULL;
}
/* Registers pidfile to be unlinked when the program terminates via exit() or a
* fatal signal. */
void
add_pidfile_to_unlink(void)
{
if (pidfile) {
fatal_signal_add_file_to_unlink(pidfile);
}
}
static void
dpdk_init__(const struct smap *ovs_other_config)
{
char **argv = NULL, **argv_to_release = NULL;
int result;
int argc, argc_tmp;
bool auto_determine = true;
int err = 0;
cpu_set_t cpuset;
char *sock_dir_subcomponent;
if (process_vhost_flags("vhost-sock-dir", xstrdup(ovs_rundir()),
NAME_MAX, ovs_other_config,
&sock_dir_subcomponent)) {
struct stat s;
if (!strstr(sock_dir_subcomponent, "..")) {
vhost_sock_dir = xasprintf("%s/%s", ovs_rundir(),
sock_dir_subcomponent);
err = stat(vhost_sock_dir, &s);
if (err) {
VLOG_ERR("vhost-user sock directory '%s' does not exist.",
vhost_sock_dir);
}
} else {
vhost_sock_dir = xstrdup(ovs_rundir());
VLOG_ERR("vhost-user sock directory request '%s/%s' has invalid"
"characters '..' - using %s instead.",
ovs_rundir(), sock_dir_subcomponent, ovs_rundir());
}
free(sock_dir_subcomponent);
} else {
vhost_sock_dir = sock_dir_subcomponent;
}
argv = grow_argv(&argv, 0, 1);
argc = 1;
argv[0] = xstrdup(ovs_get_program_name());
argc_tmp = get_dpdk_args(ovs_other_config, &argv, argc);
while (argc_tmp != argc) {
if (!strcmp("-c", argv[argc]) || !strcmp("-l", argv[argc])) {
auto_determine = false;
break;
}
argc++;
}
argc = argc_tmp;
/**
* NOTE: This is an unsophisticated mechanism for determining the DPDK
* lcore for the DPDK Master.
*/
if (auto_determine) {
int i;
/* Get the main thread affinity */
CPU_ZERO(&cpuset);
err = pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t),
&cpuset);
if (!err) {
for (i = 0; i < CPU_SETSIZE; i++) {
if (CPU_ISSET(i, &cpuset)) {
argv = grow_argv(&argv, argc, 2);
argv[argc++] = xstrdup("-c");
argv[argc++] = xasprintf("0x%08llX", (1ULL<<i));
i = CPU_SETSIZE;
}
}
} else {
VLOG_ERR("Thread getaffinity error %d. Using core 0x1", err);
/* User did not set dpdk-lcore-mask and unable to get current
* thread affintity - default to core 0x1 */
argv = grow_argv(&argv, argc, 2);
argv[argc++] = xstrdup("-c");
argv[argc++] = xasprintf("0x%X", 1);
}
}
argv = grow_argv(&argv, argc, 1);
argv[argc] = NULL;
optind = 1;
if (VLOG_IS_INFO_ENABLED()) {
struct ds eal_args;
int opt;
ds_init(&eal_args);
ds_put_cstr(&eal_args, "EAL ARGS:");
for (opt = 0; opt < argc; ++opt) {
ds_put_cstr(&eal_args, " ");
ds_put_cstr(&eal_args, argv[opt]);
}
VLOG_INFO("%s", ds_cstr_ro(&eal_args));
ds_destroy(&eal_args);
}
argv_to_release = grow_argv(&argv_to_release, 0, argc);
for (argc_tmp = 0; argc_tmp < argc; ++argc_tmp) {
argv_to_release[argc_tmp] = argv[argc_tmp];
}
/* Make sure things are initialized ... */
result = rte_eal_init(argc, argv);
if (result < 0) {
ovs_abort(result, "Cannot init EAL");
}
argv_release(argv, argv_to_release, argc);
/* Set the main thread affinity back to pre rte_eal_init() value */
if (auto_determine && !err) {
err = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t),
&cpuset);
if (err) {
VLOG_ERR("Thread setaffinity error %d", err);
}
}
rte_memzone_dump(stdout);
/* We are called from the main thread here */
RTE_PER_LCORE(_lcore_id) = NON_PMD_CORE_ID;
#ifdef DPDK_PDUMP
VLOG_INFO("DPDK pdump packet capture enabled");
err = rte_pdump_init(ovs_rundir());
if (err) {
VLOG_INFO("Error initialising DPDK pdump");
rte_pdump_uninit();
} else {
char *server_socket_path;
server_socket_path = xasprintf("%s/%s", ovs_rundir(),
"pdump_server_socket");
fatal_signal_add_file_to_unlink(server_socket_path);
free(server_socket_path);
}
#endif
/* Finally, register the dpdk classes */
netdev_dpdk_register();
}
/* If a pidfile has been configured, creates it and stores the running
* process's pid in it. Ensures that the pidfile will be deleted when the
* process exits. */
static void
make_pidfile(void)
{
long int pid = getpid();
struct stat s;
char *tmpfile;
FILE *file;
int error;
/* Create a temporary pidfile. */
if (overwrite_pidfile) {
tmpfile = xasprintf("%s.tmp%ld", pidfile, pid);
fatal_signal_add_file_to_unlink(tmpfile);
} else {
/* Everyone shares the same file which will be treated as a lock. To
* avoid some uncomfortable race conditions, we can't set up the fatal
* signal unlink until we've acquired it. */
tmpfile = xasprintf("%s.tmp", pidfile);
}
file = fopen(tmpfile, "a+");
if (!file) {
VLOG_FATAL("%s: create failed (%s)", tmpfile, ovs_strerror(errno));
}
error = lock_pidfile(file, F_SETLK);
if (error) {
/* Looks like we failed to acquire the lock. Note that, if we failed
* for some other reason (and '!overwrite_pidfile'), we will have
* left 'tmpfile' as garbage in the file system. */
VLOG_FATAL("%s: fcntl(F_SETLK) failed (%s)", tmpfile,
ovs_strerror(error));
}
if (!overwrite_pidfile) {
/* We acquired the lock. Make sure to clean up on exit, and verify
* that we're allowed to create the actual pidfile. */
fatal_signal_add_file_to_unlink(tmpfile);
check_already_running();
}
if (fstat(fileno(file), &s) == -1) {
VLOG_FATAL("%s: fstat failed (%s)", tmpfile, ovs_strerror(errno));
}
if (ftruncate(fileno(file), 0) == -1) {
VLOG_FATAL("%s: truncate failed (%s)", tmpfile, ovs_strerror(errno));
}
fprintf(file, "%ld\n", pid);
if (fflush(file) == EOF) {
VLOG_FATAL("%s: write failed (%s)", tmpfile, ovs_strerror(errno));
}
error = rename(tmpfile, pidfile);
/* Due to a race, 'tmpfile' may be owned by a different process, so we
* shouldn't delete it on exit. */
fatal_signal_remove_file_to_unlink(tmpfile);
if (error < 0) {
VLOG_FATAL("failed to rename \"%s\" to \"%s\" (%s)",
tmpfile, pidfile, ovs_strerror(errno));
}
/* Ensure that the pidfile will get deleted on exit. */
fatal_signal_add_file_to_unlink(pidfile);
/* Clean up.
*
* We don't close 'file' because its file descriptor must remain open to
* hold the lock. */
pidfile_dev = s.st_dev;
pidfile_ino = s.st_ino;
free(tmpfile);
}
/* If a pidfile has been configured, creates it and stores the running
* process's pid in it. Ensures that the pidfile will be deleted when the
* process exits. */
static void
make_pidfile(void)
{
long int pid = getpid();
struct stat s;
char *tmpfile;
FILE *file;
int error;
/* Create a temporary pidfile. */
tmpfile = xasprintf("%s.tmp%ld", pidfile, pid);
fatal_signal_add_file_to_unlink(tmpfile);
file = fopen(tmpfile, "w+");
if (!file) {
VLOG_FATAL("%s: create failed (%s)", tmpfile, strerror(errno));
}
if (fstat(fileno(file), &s) == -1) {
VLOG_FATAL("%s: fstat failed (%s)", tmpfile, strerror(errno));
}
fprintf(file, "%ld\n", pid);
if (fflush(file) == EOF) {
VLOG_FATAL("%s: write failed (%s)", tmpfile, strerror(errno));
}
error = lock_pidfile(file, F_SETLK);
if (error) {
VLOG_FATAL("%s: fcntl(F_SETLK) failed (%s)", tmpfile, strerror(error));
}
/* Rename or link it to the correct name. */
if (overwrite_pidfile) {
if (rename(tmpfile, pidfile) < 0) {
VLOG_FATAL("failed to rename \"%s\" to \"%s\" (%s)",
tmpfile, pidfile, strerror(errno));
}
} else {
do {
error = link(tmpfile, pidfile) == -1 ? errno : 0;
if (error == EEXIST) {
check_already_running();
}
} while (error == EINTR || error == EEXIST);
if (error) {
VLOG_FATAL("failed to link \"%s\" as \"%s\" (%s)",
tmpfile, pidfile, strerror(error));
}
}
/* Ensure that the pidfile will get deleted on exit. */
fatal_signal_add_file_to_unlink(pidfile);
/* Delete the temporary pidfile if it still exists. */
if (!overwrite_pidfile) {
error = fatal_signal_unlink_file_now(tmpfile);
if (error) {
VLOG_FATAL("%s: unlink failed (%s)", tmpfile, strerror(error));
}
}
/* Clean up.
*
* We don't close 'file' because its file descriptor must remain open to
* hold the lock. */
pidfile_dev = s.st_dev;
pidfile_ino = s.st_ino;
free(tmpfile);
free(pidfile);
pidfile = NULL;
}
