int conn_client_init(void) {
int errsv = 0;
if (runc.opt.remote_hostname[0]) {
if ((runc.fd = panet_client_ipv4(runc.opt.remote_hostname, runc.opt.remote_port, PANET_PROTO_TCP, 5)) == (sock_t) -1) {
errsv = errno;
log_crit("conn_client_init(): panet_client_ipv4(): %s\n", strerror(errno));
errno = errsv;
return -1;
}
#ifndef COMPILE_WIN32
} else if ((runc.fd = panet_client_unix(runc.config.network.sock_name, PANET_PROTO_UNIX_STREAM)) < 0) {
errsv = errno;
log_crit("conn_client_init(): panet_client_unix(): %s\n", strerror(errno));
errno = errsv;
return -1;
#endif
}
#ifdef COMPILE_WIN32
else {
errno = EINVAL;
return -1;
}
#endif
return 0;
}
void
core_run(void *arg_admin, void *arg_worker)
{
pthread_t worker, admin;
int ret;
if (!core_init) {
log_crit("core cannot run because it hasn't been initialized");
return;
}
ret = pthread_create(&worker, NULL, core_worker_evloop, arg_worker);
if (ret != 0) {
log_crit("pthread create failed for worker thread: %s", strerror(ret));
goto error;
}
__atomic_store_n(&admin_running, true, __ATOMIC_RELAXED);
ret = pthread_create(&admin, NULL, core_admin_evloop, arg_admin);
if (ret != 0) {
log_crit("pthread create failed for admin thread: %s", strerror(ret));
goto error;
}
core_server_evloop();
error:
core_teardown();
}
// Called from CGO code.
int dpdk_init(void)
{
int i;
engine_start_notify = (sem_t*)
malloc(sizeof(sem_t) * sysconf (_SC_NPROCESSORS_CONF));
for (i = 0; i < sysconf (_SC_NPROCESSORS_CONF); i++)
sem_init(&engine_start_notify[i], 0, 0);
// Call dpdk_main from a thread
pthread_create(&engine_thread, NULL, dpdk_init_worker, NULL);
// Wait till all cores are in engine loop
for (i = 0; i < sysconf (_SC_NPROCESSORS_CONF); i++)
sem_wait(&engine_start_notify[i]);
// Initialize the lock for virtio net linked list
pthread_mutex_init(&ll_virtio_net_lock, NULL);
// Initialize virtio framework
if (rte_vhost_driver_callback_register(&virtio_ops) < 0) {
log_crit( "rte_vhost_driver_callback_register failed\n");
return -1;
}
// Run vhost-user listener
if (pthread_create(&vhost_thread, NULL, vhost_worker, NULL) < 0) {
log_crit( "Failed to create cmd thread\n");
return -1;
}
log_info( "VHOST Socket is up and running!\n");
return 0;
}
struct mlvpn_reorder_buffer *
mlvpn_reorder_init(struct mlvpn_reorder_buffer *b, unsigned int bufsize,
unsigned int size)
{
const unsigned int min_bufsize = sizeof(*b) +
(2 * size * sizeof(mlvpn_pkt_t *));
if (b == NULL) {
log_crit("reorder", "Invalid reorder buffer parameter: NULL");
return NULL;
}
if (bufsize < min_bufsize) {
log_crit("reorder", "Invalid reorder buffer memory size: %u, "
"minimum required: %u", bufsize, min_bufsize);
return NULL;
}
memset(b, 0, bufsize);
b->memsize = bufsize;
b->order_buf.size = b->ready_buf.size = size;
b->order_buf.mask = b->ready_buf.mask = size - 1;
b->ready_buf.pkts = (void *)&b[1];
b->order_buf.pkts = (void *)&b[1] + (size * sizeof(b->ready_buf.pkts[0]));
return b;
}
struct inode_info *inodetree_insert(struct gfs2_inum di_num)
{
struct osi_node **newn = &inodetree.osi_node, *parent = NULL;
struct inode_info *data;
/* Figure out where to put new node */
while (*newn) {
struct inode_info *cur = (struct inode_info *)*newn;
parent = *newn;
if (di_num.no_addr < cur->di_num.no_addr)
newn = &((*newn)->osi_left);
else if (di_num.no_addr > cur->di_num.no_addr)
newn = &((*newn)->osi_right);
else
return cur;
}
data = malloc(sizeof(struct inode_info));
if (!data) {
log_crit( _("Unable to allocate inode_info structure\n"));
return NULL;
}
if (!memset(data, 0, sizeof(struct inode_info))) {
log_crit( _("Error while zeroing inode_info structure\n"));
return NULL;
}
/* Add new node and rebalance tree. */
data->di_num.no_addr = di_num.no_addr;
data->di_num.no_formal_ino = di_num.no_formal_ino;
osi_link_node(&data->node, parent, newn);
osi_insert_color(&data->node, &inodetree);
return data;
}
void
klog_setup(klog_options_st *options, klog_metrics_st *metrics)
{
size_t nbuf = KLOG_NBUF;
char *filename = NULL;
log_info("Set up the %s module", KLOG_MODULE_NAME);
if (klog_init) {
log_warn("%s has already been setup, overwrite", KLOG_MODULE_NAME);
log_destroy(&klogger);
}
klog_metrics = metrics;
if (options != NULL) {
filename = option_str(&options->klog_file);
klog_backup = option_str(&options->klog_backup);
if (klog_backup != NULL) {
size_t nbyte = strnlen(klog_backup, PATH_MAX + 1);
if (nbyte > PATH_MAX) {
log_crit("klog file path too long");
goto error;
}
strncpy(backup_path, klog_backup, PATH_MAX);
klog_backup = backup_path;
}
nbuf = option_uint(&options->klog_nbuf);
klog_sample = option_uint(&options->klog_sample);
if (klog_sample == 0) {
log_crit("klog sample rate cannot be 0 - divide by zero");
goto error;
}
klog_max = option_uint(&options->klog_max);
}
if (filename == NULL) { /* no klog filename provided, do not log */
klog_enabled = false;
return;
}
klogger = log_create(filename, nbuf);
if (klogger == NULL) {
log_crit("Could not create klogger!");
goto error;
}
klog_enabled = true;
klog_init = true;
return;
error:
log_destroy(&klogger);
exit(EX_CONFIG);
}
/*
* Open L2CAP server socket
*/
static bool
server_open_l2cap(server_t *srv)
{
struct sockaddr_bt sa;
int fd;
fd = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP);
if (fd == -1) {
log_crit("Could not create L2CAP socket. %s (%d)",
strerror(errno), errno);
return false;
}
if (setsockopt(fd, BTPROTO_L2CAP, SO_L2CAP_IMTU,
&srv->imtu, sizeof(srv->imtu)) == -1) {
log_crit("Could not set L2CAP Incoming MTU. %s (%d)",
strerror(errno), errno);
close(fd);
return false;
}
memset(&sa, 0, sizeof(sa));
sa.bt_len = sizeof(sa);
sa.bt_family = AF_BLUETOOTH;
sa.bt_psm = L2CAP_PSM_SDP;
bdaddr_copy(&sa.bt_bdaddr, BDADDR_ANY);
if (bind(fd, (struct sockaddr *) &sa, sizeof(sa)) == -1) {
log_crit("Could not bind L2CAP socket. %s (%d)",
strerror(errno), errno);
close(fd);
return false;
}
if (listen(fd, 5) == -1) {
log_crit("Could not listen on L2CAP socket. %s (%d)",
strerror(errno), errno);
close(fd);
return false;
}
/* Add L2CAP descriptor to index */
if (fd > srv->fdmax)
srv->fdmax = fd;
FD_SET(fd, &srv->fdset);
srv->fdidx[fd].valid = true;
srv->fdidx[fd].server = true;
srv->fdidx[fd].control = false;
srv->fdidx[fd].priv = false;
return true;
}
/**
* fix_rindex - Add the new entries to the end of the rindex file.
*/
static void fix_rindex(int rindex_fd, lgfs2_rgrps_t rgs, unsigned old_rg_count, unsigned rgcount)
{
char *buf;
ssize_t count;
ssize_t writelen;
const size_t entrysize = sizeof(struct gfs2_rindex);
log_info( _("%d new rindex entries.\n"), rgcount);
buf = rindex_buffer(rgs, rgcount);
writelen = rgcount * entrysize;
if (!test) {
off_t rindex_size = lseek(rindex_fd, 0, SEEK_END);
if (rindex_size != old_rg_count * entrysize) {
log_crit(_("Incorrect rindex size. Want %ld (%d resource groups), have %ld\n"),
(long)(old_rg_count * entrysize), old_rg_count,
(long)rindex_size);
goto out;
}
/* Write the first entry separately to ensure there's enough
space in the fs for the rest */
count = write(rindex_fd, buf, entrysize);
if (count != entrysize) {
log_crit(_("Error writing first new rindex entry; aborted.\n"));
if (count > 0)
goto trunc;
else
goto out;
}
count = write(rindex_fd, (buf + entrysize), (writelen - entrysize));
if (count != (writelen - entrysize)) {
log_crit(_("Error writing new rindex entries; aborted.\n"));
if (count > 0)
goto trunc;
else
goto out;
}
if (fallocate(rindex_fd, FALLOC_FL_KEEP_SIZE, (rindex_size + writelen), entrysize) != 0)
perror("fallocate");
fsync(rindex_fd);
}
out:
free(buf);
return;
trunc:
count = (count / sizeof(struct gfs2_rindex)) + old_rg_count;
log_crit(_("truncating rindex to %ld entries\n"),
(long)count * sizeof(struct gfs2_rindex));
ftruncate(rindex_fd, (off_t)count * sizeof(struct gfs2_rindex));
free(buf);
}
/*
* Initialize server
*/
bool
server_init(server_t *srv, char const *control, char const *sgroup)
{
assert(srv != NULL);
assert(control != NULL);
memset(srv, 0, sizeof(*srv));
FD_ZERO(&srv->fdset);
srv->sgroup = sgroup;
srv->fdmax = -1;
srv->fdidx = calloc(FD_SETSIZE, sizeof(fd_idx_t));
if (srv->fdidx == NULL) {
log_crit("Failed to allocate fd index");
goto fail;
}
srv->ctllen = CMSG_SPACE(SOCKCREDSIZE(MAX_GROUPS));
srv->ctlbuf = malloc(srv->ctllen);
if (srv->ctlbuf == NULL) {
log_crit("Malloc cmsg buffer (len=%zu) failed.", srv->ctllen);
goto fail;
}
srv->imtu = SDP_LOCAL_MTU - sizeof(sdp_pdu_t);
srv->ibuf = malloc(srv->imtu);
if (srv->ibuf == NULL) {
log_crit("Malloc input buffer (imtu=%d) failed.", srv->imtu);
goto fail;
}
srv->omtu = L2CAP_MTU_DEFAULT - sizeof(sdp_pdu_t);
srv->obuf = malloc(srv->omtu);
if (srv->obuf == NULL) {
log_crit("Malloc output buffer (omtu=%d) failed.", srv->omtu);
goto fail;
}
if (db_init(srv)
&& server_open_control(srv, control)
&& server_open_l2cap(srv))
return true;
fail:
server_shutdown(srv);
return false;
}
static void
update_shared_memory(char *last_wal_standby_applied)
{
PGresult *res;
char sqlquery[QUERY_STR_LEN];
sprintf(sqlquery, "SELECT %s.repmgr_update_standby_location('%s')",
repmgr_schema, last_wal_standby_applied);
/* If an error happens, just inform about that and continue */
res = PQexec(my_local_conn, sqlquery);
if (PQresultStatus(res) != PGRES_TUPLES_OK)
{
log_warning(_("Cannot update this standby's shared memory: %s\n"),
PQerrorMessage(my_local_conn));
/* XXX is this enough reason to terminate this repmgrd? */
}
else if (strcmp(PQgetvalue(res, 0, 0), "f") == 0)
{
/* this surely is more than enough reason to exit */
log_crit(_("Cannot update this standby's shared memory, maybe shared_preload_libraries=repmgr_funcs is not set?\n"));
exit(ERR_BAD_CONFIG);
}
PQclear(res);
}
int alloc_tun(const char *tun_up_cmd) {
const char *dev = "tun%d";
struct ifreq ifr;
int fd, err;
char buff[100];
if((fd = open("/dev/net/tun", O_RDWR)) < 0)
fatal("tun", "ioctl call for tun device failed");
memset(&ifr, 0, sizeof(ifr));
ifr.ifr_flags = IFF_TUN;
if(*dev)
strncpy(ifr.ifr_name, dev, IFNAMSIZ);
if((err = ioctl(fd, TUNSETIFF, (void *) &ifr)) < 0){
fatal("tun", "ioctl TUNSETIFF call for tun device failed");
close(fd);
return err;
}
log_info("tun", "Opened device %s [fd: %d], will run the command [%s] now", ifr.ifr_name, fd, tun_up_cmd);
int env_var_len = snprintf(buff, sizeof(buff), "TUN_IFACE=%s", ifr.ifr_name);
assert(env_var_len > 0 && (unsigned) env_var_len < sizeof(buff));
assert(putenv(buff) == 0);
int ret = system(tun_up_cmd);
if (ret != 0) {
log_crit("tun", "TUN-UP command '%s' failed, return code was %d", tun_up_cmd, ret);
return -1;
}
return fd;
}
static void _init(int argc, char **argv) {
if (runtime_client_init(argc, argv) < 0) {
log_crit("_init(): runtime_client_init(): %s\n", strerror(errno));
print_client_result_error();
exit(EXIT_FAILURE);
}
}
/*
* Accept new client connection and register it with index
*/
static void
server_accept_client(server_t *srv, int fd)
{
struct sockaddr_bt sa;
socklen_t len;
int cfd;
uint16_t omtu;
do {
cfd = accept(fd, NULL, NULL);
} while (cfd == -1 && errno == EINTR);
if (cfd == -1) {
log_err("Could not accept connection on %s socket. %s (%d)",
srv->fdidx[fd].control ? "control" : "L2CAP",
strerror(errno), errno);
return;
}
if (cfd >= FD_SETSIZE) {
log_crit("File descriptor too large");
close(cfd);
return;
}
assert(!FD_ISSET(cfd, &srv->fdset));
assert(!srv->fdidx[cfd].valid);
memset(&sa, 0, sizeof(sa));
omtu = srv->omtu;
if (!srv->fdidx[fd].control) {
len = sizeof(sa);
if (getsockname(cfd, (struct sockaddr *)&sa, &len) == -1)
log_warning("getsockname failed, using BDADDR_ANY");
len = sizeof(omtu);
if (getsockopt(cfd, BTPROTO_L2CAP, SO_L2CAP_OMTU, &omtu, &len) == -1)
log_warning("Could not get L2CAP OMTU, using %d", omtu);
else
omtu -= sizeof(sdp_pdu_t);
}
/* Add client descriptor to the index */
if (cfd > srv->fdmax)
srv->fdmax = cfd;
FD_SET(cfd, &srv->fdset);
srv->fdidx[cfd].valid = true;
srv->fdidx[cfd].server = false;
srv->fdidx[cfd].control = srv->fdidx[fd].control;
srv->fdidx[cfd].priv = false;
srv->fdidx[cfd].omtu = (omtu > srv->omtu) ? srv->omtu : omtu;
srv->fdidx[cfd].offset = 0;
bdaddr_copy(&srv->fdidx[cfd].bdaddr, &sa.bt_bdaddr);
log_debug("new %s client on fd#%d",
srv->fdidx[cfd].control ? "control" : "L2CAP", cfd);
}
// Called when user wants to update the fds list for a engine loop.
// This happens when a virtio/vm is created/destroyed.
static void engine_cmd_callback(uint16_t lcore_id, void* data)
{
struct cmd_event_info* info = (struct cmd_event_info*)data;
struct engine_cmd_msg* msg;
eventfd_read(lcore_cmd_event_fd[lcore_id], (eventfd_t*) &msg);
if (msg->cmd == ENGINE_CMD_FD_ADD) {
memset(&info->fds[msg->slot], 0, sizeof(struct pollfd));
info->event_handlers[msg->slot].data = msg->handler.data;
info->event_handlers[msg->slot].fn = msg->handler.fn;
info->fds[msg->slot].events = POLLIN|POLLERR;
info->fds[msg->slot].fd = msg->fd;
(*info->nb_fd)++;
free(msg);
}
else if (msg->cmd == ENGINE_CMD_FD_DEL) {
void* arg = info->event_handlers[msg->slot].data;
memset(&info->fds[msg->slot], 0, sizeof(struct pollfd));
(*info->nb_fd)--;
free(arg);
free(msg);
}
else {
log_crit("Unrecongnized command received\n");
free(msg);
}
}
static void _do(void) {
/* Transmit entries */
if (conn_client_process() < 0) {
log_crit("_do: conn_client_process(): %s\n", strerror(errno));
print_client_result_error();
exit(EXIT_FAILURE);
}
}
////////////////////////////////////////
// p_device: ignored
// p_parity
// false: N81 (none, 8 data, 1 stop)
// true: E71 (even, 7 data, 1 stop)
bool sp_init(const char* p_device, const uint16_t p_baud, const bool p_parity)
{
sp_close();
log_notice("opening %s at %d baud, %s\n", p_device, p_baud, (p_parity ? "E71" : "N81"));
const speed_t baudrate = sp_parse_baudrate(p_baud);
if(0 == baudrate)
{
log_crit("baudrate not supported");
return(false);
}
// open serial device for reading and writing and not as controlling tty so we don't get killed by CTRL-C
s_fd = open(p_device, O_RDWR | O_NOCTTY | O_NDELAY);
if(s_fd < 0)
{
log_crit("failed to open device: %s", p_device);
return(false);
}
struct termios tio = { 0 };
cfsetspeed(&tio, baudrate);
if(p_parity)
{
tio.c_cflag |= (CS7 | PARENB | CLOCAL | CREAD);
}
else
{
tio.c_cflag |= (CS8 | CLOCAL | CREAD);
}
// ignore bytes with parity errors
tio.c_iflag = IGNPAR;
// raw output
tio.c_oflag = 0;
// local modes
tio.c_lflag = 0;
// clean the modem line and activate the settings for the port
tcflush(s_fd, TCIOFLUSH);
tcsetattr(s_fd, TCSANOW, &tio);
return(true);
}
static void _failure(const char *caller) {
fprintf(stderr, "[%s] %s() error: %s\n", CONFIG_USCHED_MONITOR_PROC_NAME, caller, strerror(errno));
log_crit("_failure(): %s(): %s\n", caller, strerror(errno));
_config_destroy();
exit(EXIT_FAILURE);
}
void sig_term(int sig)
{
if (sig == SIGTERM) {
log_crit("Terminating ... ");
unlink(pidFile.c_str());
exit(0);
}
}
int exec_admin_delta_noexec_change(const char *delta_noexec) {
int errsv = 0;
if (admin_property_change(CONFIG_USCHED_DIR_EXEC, CONFIG_USCHED_FILE_EXEC_DELTA_NOEXEC, delta_noexec) < 0) {
errsv = errno;
log_crit("exec_admin_delta_noexec_change(): admin_property_change(): %s\n", strerror(errno));
errno = errsv;
return -1;
}
if (exec_admin_delta_noexec_show() < 0) {
errsv = errno;
log_crit("exec_admin_delta_noexec_change(): exec_admin_delta_noexec_show(): %s\n", strerror(errno));
errno = errsv;
return -1;
}
return 0;
}
/* Bottom half support */
static int schedule_work(void* (*workfn)(void* data), void *arg)
{
pthread_t th;
if (pthread_create(&th, NULL, workfn, arg) < 0) {
log_crit("Failed to create work function thread\n");
return -1;
}
return 0;
}
void
core_server_evloop(void)
{
for(;;) {
if (_server_evwait() != CC_OK) {
log_crit("server core event loop exited due to failure");
break;
}
}
}
int main(int argc, char *argv[])
{
char *envp = NULL;
set_oom_adj(-1000);
if (initService(argc, argv) != 0)
return -1;
envp = ::getenv("SCI_DISABLE_IPV6");
if (envp && (::strcasecmp(envp, "yes") == 0)) {
Socket::setDisableIPv6(1);
}
ExtListener *listener = new ExtListener();
listener->start();
launcherList.clear();
while (1) {
Locker::getLocker()->freeze();
log_debug("Delete unused launcher");
Locker::getLocker()->lock();
vector<ExtLauncher *>::iterator lc;
for (lc = launcherList.begin(); lc != launcherList.end(); lc++) {
while (!(*lc)->isLaunched()) {
// before join, this thread should have been launched
SysUtil::sleep(WAIT_INTERVAL);
}
(*lc)->join();
delete (*lc);
}
launcherList.clear();
Locker::getLocker()->unlock();
log_info("Begin to cleanup the jobInfo");
Locker::getLocker()->lock();
JOB_INFO::iterator it;
for (it = jobInfo.begin(); it != jobInfo.end(); ) {
if ((SysUtil::microseconds() - it->second.timestamp) > FIVE_MINUTES) {
log_crit("Erase jobInfo item %d", it->first);
jobInfo.erase(it++);
} else {
++it;
}
}
log_info("Finish cleanup the jobInfo");
Locker::getLocker()->unlock();
}
listener->join();
delete listener;
delete Log::getInstance();
return 0;
}
static int _bexec(
const char *file,
char *const *args)
{
int status = 0;
pid_t ret = 0;
if ((config.cpid = fork()) > 0) {
if ((config.flags & CONFIG_FL_PIDF_CREATE) && (_file_pid_write(config.cpid) < 0)) {
log_crit("_bexec(): _file_pid_write(): %s\n", strerror(errno));
return -1;
}
/* SA_RESTART set */
do {
if ((ret = waitpid(config.cpid, &status, 0)) != (pid_t) -1)
break;
log_crit("_bexec(): waitpid(%u, &status, 0): %s\n", config.cpid, strerror(errno));
} while (errno == EINTR); /* Restart the syscall if it was interrupted by a signal */
/* Check if we've an error condition from waitpid() */
if (ret == (pid_t) -1)
return -1;
/* Success? */
if (WEXITSTATUS(status) != EXIT_SUCCESS)
log_crit("_bexec(): Execution of '%s' terminated with error status code %d.\n", file, WEXITSTATUS(status));
} else if (!config.cpid) {
_config_destroy();
if (setsid() == (pid_t) -1)
_failure("setsid");
if (execve(file, args, environ) < 0)
_failure("execve");
return -1;
}
return status;
}
static int get_session_table(l4_protocol l4_proto, struct session_table **result)
{
switch (l4_proto) {
case L4PROTO_UDP:
*result = &session_table_udp;
return 0;
case L4PROTO_TCP:
*result = &session_table_tcp;
return 0;
case L4PROTO_ICMP:
*result = &session_table_icmp;
return 0;
case L4PROTO_NONE:
log_crit(ERR_L4PROTO, "There is no session table for the 'NONE' protocol.");
return -EINVAL;
}
log_crit(ERR_L4PROTO, "Unsupported transport protocol: %u.", l4_proto);
return -EINVAL;
}
int thread_daemon_components_init(void) {
int errsv = 0;
if ((errno = pthread_mutex_init(&rund.mutex_interrupt, NULL))) {
errsv = errno;
log_crit("thread_daemon_components_init(): pthread_mutex_init(): %s\n", strerror(errno));
errno = errsv;
return -1;
}
if ((errno = pthread_mutex_init(&rund.mutex_rpool, NULL))) {
errsv = errno;
log_crit("thread_daemon_components_init(): pthread_mutex_init(): %s\n", strerror(errno));
errno = errsv;
return -1;
}
if ((errno = pthread_mutex_init(&rund.mutex_apool, NULL))) {
errsv = errno;
log_crit("thread_daemon_components_init(): pthread_mutex_init(): %s\n", strerror(errno));
errno = errsv;
return -1;
}
#if CONFIG_USCHED_SERIALIZE_ON_REQ == 1
if ((errno = pthread_mutex_init(&rund.mutex_marshal, NULL))) {
errsv = errno;
log_crit("thread_daemon_components_init(): pthread_mutex_init(): %s\n", strerror(errno));
errno = errsv;
return -1;
}
if ((errno = pthread_cond_init(&rund.cond_marshal, NULL))) {
errsv = errno;
log_crit("thread_daemon_components_init(): pthread_cond_init(): %s\n", strerror(errno));
errno = errsv;
return -1;
}
#endif
return 0;
}
int schedule_daemon_init(void) {
int errsv = 0;
if (!(rund.psched = psched_thread_init())) {
errsv = errno;
log_crit("schedule_daemon_init(): psched_thread_init(): %s\n", strerror(errno));
errno = errsv;
return -1;
}
return 0;
}
static void _file_pid_create(const char *file) {
config.fd_pidf = open(file, O_RDONLY);
if ((config.fd_pidf >= 0) && (config.flags & CONFIG_FL_PIDF_FORCE)) {
if (unlink(file) < 0)
_failure("unlink");
} else if (config.fd_pidf >= 0) {
log_crit("_file_pid_create(): PID file %s already exists\n", file);
fprintf(stderr, "PID file %s already exists.\n", file);
_config_destroy();
exit(EXIT_FAILURE);
}
_close_safe(config.fd_pidf);
if ((config.fd_pidf = open(file, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR)) < 0) {
log_crit("_file_pid_create(): open(): Cannot create PID file %s: %s.\n", file, strerror(errno));
fprintf(stderr, "Cannot create PID file %s.\n", file);
_failure("open");
}
}
int exec_admin_show(void) {
int errsv = 0;
if (exec_admin_delta_noexec_show() < 0) {
errsv = errno;
log_crit("exec_admin_show(): exec_admin_delta_noexec_show(): %s\n", strerror(errno));
errno = errsv;
return -1;
}
return 0;
}
/* rte_vhost_driver_session_start is a blocking call, thus we create another
* thread and call it from there */
static void* vhost_worker(CC_UNUSED void* arg)
{
pthread_detach(pthread_self());
log_info("vhost_worker started\n");
if (rte_vhost_driver_session_start() < 0) {
log_crit( "rte_vhost_driver_register failed to start\n");
}
return NULL;
}
int exec_admin_delta_noexec_show(void) {
int errsv = 0;
if (admin_property_show(CONFIG_USCHED_DIR_EXEC, USCHED_CATEGORY_EXEC_STR, CONFIG_USCHED_FILE_EXEC_DELTA_NOEXEC) < 0) {
errsv = errno;
log_crit("exec_admin_delta_noexec_show(): admin_property_show(): %s\n", strerror(errno));
errno = errsv;
return -1;
}
/* All good */
return 0;
}
