int efx_vi_alloc(struct efx_vi_state **vih_out, int ifindex)
{
struct efx_vi_state *efx_state;
int rc;
efx_state = kmalloc(sizeof(struct efx_vi_state), GFP_KERNEL);
if (!efx_state) {
EFRM_ERR("%s: failed to allocate memory for efx_vi_state",
__func__);
rc = -ENOMEM;
goto fail;
}
efx_state->ifindex = ifindex;
rc = efrm_client_get(ifindex, NULL, NULL, &efx_state->efrm_client);
if (rc < 0) {
EFRM_ERR("%s: efrm_client_get(%d) failed: %d", __func__,
ifindex, rc);
rc = -ENODEV;
goto fail_no_ifindex;
}
efx_state->nic = efrm_client_get_nic(efx_state->efrm_client);
init_completion(&efx_state->flush_completion);
/* basically allocate_pt_endpoint() */
rc = alloc_ep(efx_state);
if (rc) {
EFRM_ERR("%s: alloc_ep failed: %d", __func__, rc);
goto fail_no_pt;
}
#if EFX_VI_STATIC_FILTERS
/* Statically allocate a set of filter resources - removes the
restriction on not being able to use efx_vi_filter() from
in_atomic() */
rc = efx_vi_alloc_static_filters(efx_state);
if (rc)
goto fail_no_filters;
#endif
*vih_out = efx_state;
return 0;
#if EFX_VI_STATIC_FILTERS
fail_no_filters:
free_ep(efx_state);
#endif
fail_no_pt:
efrm_client_put(efx_state->efrm_client);
fail_no_ifindex:
kfree(efx_state);
fail:
return rc;
}
External_Process*
spawn_external (char* cmd)
{
External_Process* ep;
int rc;
ep = alloc_ep ();
if (!ep) return 0;
/* Create the pipes */
rc = pipe (ep->mypipe);
if (rc) {
fprintf (stderr, "Can't open pipes\n");
free (ep);
return 0;
}
/* Create the child process. */
ep->pid = fork ();
if (ep->pid == (pid_t) 0) {
/* This is the child process. */
int i = 0;
char** argv;
close (ep->mypipe[0]);
dup2 (ep->mypipe[1],1);
close (ep->mypipe[1]);
argv = buildargv (cmd);
while (argv[i]) {
debug_printf ("argv[%d] = %s\n", i, argv[i]);
i++;
}
execvp (argv[0],&argv[0]);
/* Doesn't return */
fprintf (stderr, "Error, returned from execlp\n");
exit (-1);
} else if (ep->pid < (pid_t) 0) {
/* The fork failed. */
close (ep->mypipe[0]);
close (ep->mypipe[1]);
fprintf (stderr, "Fork failed.\n");
free (ep);
return 0;
} else {
/* This is the parent process. */
close (ep->mypipe[1]);
rc = fcntl (ep->mypipe[0], F_SETFL, O_NONBLOCK);
return ep;
}
}
static int init_fabric(void)
{
int ret;
ret = ft_getinfo(hints, &fi);
if (ret)
return ret;
ret = get_dupinfo();
if (ret)
return ret;
ret = ft_open_fabric_res();
if (ret)
return ret;
av_attr.count = ep_cnt;
ret = alloc_ep_res(fi);
if (ret)
return ret;
ret = alloc_ep();
if (ret)
return ret;
ret = bind_ep_array_res();
if (ret)
return ret;
/* Post recv */
if (rx_shared_ctx)
ret = ft_post_rx(srx_ctx, MAX(rx_size, FT_MAX_CTRL_MSG), &rx_ctx);
else
ret = ft_post_rx(ep_array[0], MAX(rx_size, FT_MAX_CTRL_MSG), &rx_ctx);
if (ret)
return ret;
ret = init_av();
return ret;
}
static int client_connect(void)
{
struct fi_eq_cm_entry entry;
uint32_t event;
ssize_t rd;
int i, ret;
ret = ft_getinfo(hints, &fi);
if (ret)
return ret;
ret = get_dupinfo();
if (ret)
return ret;
ret = ft_open_fabric_res();
if (ret)
return ret;
ret = alloc_ep_res(fi);
if (ret)
return ret;
ret = alloc_ep();
if (ret)
return ret;
ret = bind_ep_array_res();
if (ret)
return ret;
for (i = 0; i < ep_cnt; i++) {
ret = fi_connect(ep_array[i], fi->dest_addr, NULL, 0);
if (ret) {
FT_PRINTERR("fi_connect", ret);
return ret;
}
rd = fi_eq_sread(eq, &event, &entry, sizeof entry, -1, 0);
if (rd != sizeof entry) {
FT_PROCESS_EQ_ERR(rd, eq, "fi_eq_sread", "connect");
ret = (int) rd;
return ret;
}
if (event != FI_CONNECTED || entry.fid != &ep_array[i]->fid) {
fprintf(stderr, "Unexpected CM event %d fid %p (ep %p)\n",
event, entry.fid, ep);
ret = -FI_EOTHER;
return ret;
}
}
/* Post recv */
if (rx_shared_ctx)
ret = ft_post_rx(srx_ctx, MAX(rx_size, FT_MAX_CTRL_MSG), &rx_ctx);
else
ret = ft_post_rx(ep_array[0], MAX(rx_size, FT_MAX_CTRL_MSG), &rx_ctx);
if (ret)
return ret;
return 0;
}
External_Process*
spawn_external (char* cmd)
{
External_Process* ep;
HANDLE hChildStdinRd;
HANDLE hChildStdinWr;
HANDLE hChildStdoutWr;
SECURITY_ATTRIBUTES saAttr;
PROCESS_INFORMATION piProcInfo;
STARTUPINFO startup_info;
BOOL rc;
DWORD creation_flags;
ep = alloc_ep ();
if (!ep) return 0;
/* Set the bInheritHandle flag so pipe handles are inherited. */
saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
saAttr.bInheritHandle = TRUE;
saAttr.lpSecurityDescriptor = NULL;
/* Create a pipe for the child process's STDOUT. */
if (!CreatePipe (&ep->mypipe, &hChildStdoutWr, &saAttr, 0)) {
debug_printf ("Stdout pipe creation failed\n");
free (ep);
return 0;
}
/* Ensure the read handle to the pipe for STDOUT is not inherited.*/
SetHandleInformation (ep->mypipe, HANDLE_FLAG_INHERIT, 0);
/* Create a pipe for the child process's STDIN. */
if (!CreatePipe (&hChildStdinRd, &hChildStdinWr, &saAttr, 0)) {
debug_printf ("Stdin pipe creation failed\n");
free (ep);
return 0;
}
/* Ensure the write handle to the pipe for STDIN is not inherited. */
SetHandleInformation (hChildStdinWr, HANDLE_FLAG_INHERIT, 0);
/* create the child process */
ZeroMemory (&piProcInfo, sizeof(PROCESS_INFORMATION));
ZeroMemory (&startup_info, sizeof(STARTUPINFO));
startup_info.cb = sizeof(STARTUPINFO);
startup_info.hStdError = hChildStdoutWr;
startup_info.hStdOutput = hChildStdoutWr;
startup_info.hStdInput = hChildStdinRd;
startup_info.dwFlags |= STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
//startup_info.wShowWindow = SW_SHOW;
startup_info.wShowWindow = SW_HIDE;
creation_flags = 0;
creation_flags |= CREATE_NEW_PROCESS_GROUP;
//creation_flags |= CREATE_NEW_CONSOLE;
rc = CreateProcess (
NULL, // executable name
cmd, // command line
NULL, // process security attributes
NULL, // primary thread security attributes
TRUE, // handles are inherited
creation_flags, // creation flags
NULL, // use parent's environment
NULL, // use parent's current directory
&startup_info, // STARTUPINFO pointer
&piProcInfo); // receives PROCESS_INFORMATION
if (rc == 0) {
debug_printf ("CreateProcess() failed\n");
free (ep);
return 0;
}
ep->hproc = piProcInfo.hProcess;
ep->pid = piProcInfo.dwProcessId;
//CloseHandle (piProcInfo.hProcess);
CloseHandle (piProcInfo.hThread);
Sleep (0);
return ep;
}
