/*
test a echodata call over the internal messaging system
*/
static bool test_echodata(struct torture_context *tctx,
const void *tcase_data,
const void *test_data)
{
struct echo_EchoData r;
NTSTATUS status;
const struct irpc_test_data *data = (const struct irpc_test_data *)tcase_data;
TALLOC_CTX *mem_ctx = tctx;
struct dcerpc_binding_handle *irpc_handle;
irpc_handle = irpc_binding_handle(mem_ctx, data->msg_ctx1,
cluster_id(0, MSG_ID2),
&ndr_table_rpcecho);
torture_assert(tctx, irpc_handle, "no memory");
/* make the call */
r.in.in_data = (unsigned char *)talloc_strdup(mem_ctx, "0123456789");
r.in.len = strlen((char *)r.in.in_data);
status = dcerpc_echo_EchoData_r(irpc_handle, mem_ctx, &r);
torture_assert_ntstatus_ok(tctx, status, "EchoData failed");
/* check the answer */
if (memcmp(r.out.out_data, r.in.in_data, r.in.len) != 0) {
NDR_PRINT_OUT_DEBUG(echo_EchoData, &r);
torture_fail(tctx, "EchoData wrong answer");
}
torture_comment(tctx, "Echo '%*.*s' -> '%*.*s'\n",
r.in.len, r.in.len,
r.in.in_data,
r.in.len, r.in.len,
r.out.out_data);
return true;
}
/*
test a addone call over the internal messaging system
*/
static bool test_addone(struct torture_context *test, const void *_data,
const void *_value)
{
struct echo_AddOne r;
NTSTATUS status;
const struct irpc_test_data *data = (const struct irpc_test_data *)_data;
uint32_t value = *(const uint32_t *)_value;
struct dcerpc_binding_handle *irpc_handle;
irpc_handle = irpc_binding_handle(test, data->msg_ctx1,
cluster_id(0, MSG_ID2),
&ndr_table_rpcecho);
torture_assert(test, irpc_handle, "no memory");
/* make the call */
r.in.in_data = value;
test_debug = true;
status = dcerpc_echo_AddOne_r(irpc_handle, test, &r);
test_debug = false;
torture_assert_ntstatus_ok(test, status, "AddOne failed");
/* check the answer */
torture_assert(test, *r.out.out_data == r.in.in_data + 1,
"AddOne wrong answer");
torture_comment(test, "%u + 1 = %u\n", r.in.in_data, *r.out.out_data);
return true;
}
/*
called to create a new server task
*/
static void onefork_new_task(struct tevent_context *ev,
struct loadparm_context *lp_ctx,
const char *service_name,
void (*new_task_fn)(struct tevent_context *, struct loadparm_context *lp_ctx, struct server_id , void *),
void *private_data)
{
pid_t pid;
pid = fork();
if (pid != 0) {
/* parent or error code ... go back to the event loop */
return;
}
pid = getpid();
if (tevent_re_initialise(ev) != 0) {
smb_panic("Failed to re-initialise tevent after fork");
}
setproctitle("task %s server_id[%d]", service_name, (int)pid);
onefork_reload_after_fork();
/* setup this new connection: process will bind to it's sockets etc */
new_task_fn(ev, lp_ctx, cluster_id(pid, 0), private_data);
event_loop_wait(ev);
talloc_free(ev);
exit(0);
}
/*
this creates a stream_connection from an already existing connection,
used for protocols, where a client connection needs to switched into
a server connection
*/
NTSTATUS stream_new_connection_merge(struct tevent_context *ev,
struct loadparm_context *lp_ctx,
const struct model_ops *model_ops,
const struct stream_server_ops *stream_ops,
struct imessaging_context *msg_ctx,
void *private_data,
struct stream_connection **_srv_conn)
{
struct stream_connection *srv_conn;
srv_conn = talloc_zero(ev, struct stream_connection);
NT_STATUS_HAVE_NO_MEMORY(srv_conn);
srv_conn->private_data = private_data;
srv_conn->model_ops = model_ops;
srv_conn->socket = NULL;
srv_conn->server_id = cluster_id(0, 0);
srv_conn->ops = stream_ops;
srv_conn->msg_ctx = msg_ctx;
srv_conn->event.ctx = ev;
srv_conn->lp_ctx = lp_ctx;
srv_conn->event.fde = NULL;
*_srv_conn = srv_conn;
return NT_STATUS_OK;
}
/*
called to create a new server task
*/
static void standard_new_task(struct tevent_context *ev,
struct loadparm_context *lp_ctx,
const char *service_name,
void (*new_task)(struct tevent_context *, struct loadparm_context *lp_ctx, struct server_id , void *),
void *private_data)
{
pid_t pid;
struct tevent_context *ev2;
pid = fork();
if (pid != 0) {
/* parent or error code ... go back to the event loop */
return;
}
pid = getpid();
/* This is now the child code. We need a completely new event_context to work with */
ev2 = s4_event_context_init(NULL);
/* setup this as the default context */
s4_event_context_set_default(ev2);
/* the service has given us a private pointer that
encapsulates the context it needs for this new connection -
everything else will be freed */
talloc_steal(ev2, private_data);
/* this will free all the listening sockets and all state that
is not associated with this new connection */
talloc_free(ev);
/* ldb/tdb need special fork handling */
ldb_wrap_fork_hook();
tevent_add_fd(ev2, ev2, child_pipe[0], TEVENT_FD_READ,
standard_pipe_handler, NULL);
close(child_pipe[1]);
/* Ensure that the forked children do not expose identical random streams */
set_need_random_reseed();
setproctitle("task %s server_id[%d]", service_name, pid);
/* setup this new task. Cluster ID is PID based for this process modal */
new_task(ev2, lp_ctx, cluster_id(pid, 0), private_data);
/* we can't return to the top level here, as that event context is gone,
so we now process events in the new event context until there are no
more to process */
event_loop_wait(ev2);
talloc_free(ev2);
exit(0);
}
/*
called to create a new server task
*/
static void standard_new_task(struct tevent_context *ev,
struct loadparm_context *lp_ctx,
const char *service_name,
void (*new_task)(struct tevent_context *, struct loadparm_context *lp_ctx, struct server_id , void *),
void *private_data)
{
pid_t pid;
pid = fork();
if (pid != 0) {
/* parent or error code ... go back to the event loop */
return;
}
pid = getpid();
/* this will free all the listening sockets and all state that
is not associated with this new connection */
if (tevent_re_initialise(ev) != 0) {
smb_panic("Failed to re-initialise tevent after fork");
}
/* ldb/tdb need special fork handling */
ldb_wrap_fork_hook();
tevent_add_fd(ev, ev, child_pipe[0], TEVENT_FD_READ,
standard_pipe_handler, NULL);
close(child_pipe[1]);
/* Ensure that the forked children do not expose identical random streams */
set_need_random_reseed();
setproctitle("task %s server_id[%d]", service_name, (int)pid);
/* setup this new task. Cluster ID is PID based for this process modal */
new_task(ev, lp_ctx, cluster_id(pid, 0), private_data);
/* we can't return to the top level here, as that event context is gone,
so we now process events in the new event context until there are no
more to process */
event_loop_wait(ev);
talloc_free(ev);
exit(0);
}
/*
setup messaging for the top level samba (parent) task
*/
static NTSTATUS setup_parent_messaging(struct tevent_context *event_ctx,
struct loadparm_context *lp_ctx)
{
struct imessaging_context *msg;
NTSTATUS status;
msg = imessaging_init(talloc_autofree_context(),
lpcfg_imessaging_path(event_ctx, lp_ctx),
cluster_id(0, SAMBA_PARENT_TASKID), event_ctx, false);
NT_STATUS_HAVE_NO_MEMORY(msg);
irpc_add_name(msg, "samba");
status = IRPC_REGISTER(msg, irpc, SAMBA_TERMINATE,
samba_terminate, NULL);
return status;
}
/*
called when a listening socket becomes readable.
*/
static void single_accept_connection(struct tevent_context *ev,
struct loadparm_context *lp_ctx,
struct socket_context *listen_socket,
void (*new_conn)(struct tevent_context *,
struct loadparm_context *,
struct socket_context *,
struct server_id , void *),
void *private_data)
{
NTSTATUS status;
struct socket_context *connected_socket;
pid_t pid = getpid();
/* accept an incoming connection. */
status = socket_accept(listen_socket, &connected_socket);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("single_accept_connection: accept: %s\n", nt_errstr(status)));
/* this looks strange, but is correct.
We can only be here if woken up from select, due to
an incoming connection.
We need to throttle things until the system clears
enough resources to handle this new socket.
If we don't then we will spin filling the log and
causing more problems. We don't panic as this is
probably a temporary resource constraint */
sleep(1);
return;
}
talloc_steal(private_data, connected_socket);
/*
* We use the PID so we cannot collide in with cluster ids
* generated in other single mode tasks, and, and won't
* collide with PIDs from process model standard because a the
* combination of pid/fd should be unique system-wide
*/
new_conn(ev, lp_ctx, connected_socket,
cluster_id(pid, socket_get_fd(connected_socket)), private_data);
}
/*
called when a listening socket becomes readable.
*/
static void prefork_accept_connection(
struct tevent_context *ev,
struct loadparm_context *lp_ctx,
struct socket_context *listen_socket,
void (*new_conn)(struct tevent_context *,
struct loadparm_context *,
struct socket_context *,
struct server_id,
void *,
void *),
void *private_data,
void *process_context)
{
NTSTATUS status;
struct socket_context *connected_socket;
pid_t pid = getpid();
/* accept an incoming connection. */
status = socket_accept(listen_socket, &connected_socket);
if (!NT_STATUS_IS_OK(status)) {
/*
* For prefork we can ignore STATUS_MORE_ENTRIES, as once a
* connection becomes available all waiting processes are
* woken, but only one gets work to process.
* AKA the thundering herd.
* In the short term this should not be an issue as the number
* of workers should be a small multiple of the number of cpus
* In the longer term socket_accept needs to implement a
* mutex/semaphore (like apache does) to serialise the accepts
*/
if (!NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) {
DBG_ERR("Worker process (%d), error in accept [%s]\n",
getpid(), nt_errstr(status));
}
return;
}
talloc_steal(private_data, connected_socket);
new_conn(ev, lp_ctx, connected_socket,
cluster_id(pid, socket_get_fd(connected_socket)),
private_data, process_context);
}
/*
called to startup a new task
*/
static void single_new_task(struct tevent_context *ev,
struct loadparm_context *lp_ctx,
const char *service_name,
void (*new_task)(struct tevent_context *, struct loadparm_context *, struct server_id, void *),
void *private_data)
{
pid_t pid = getpid();
/* start our taskids at MAX_INT32, the first 2^31 tasks are is reserved for fd numbers */
static uint32_t taskid = INT32_MAX;
/*
* We use the PID so we cannot collide in with cluster ids
* generated in other single mode tasks, and, and won't
* collide with PIDs from process model starndard because a the
* combination of pid/task_id should be unique system-wide
*
* Using the pid unaltered makes debugging of which process
* owns the messaging socket easier.
*/
new_task(ev, lp_ctx, cluster_id(pid, taskid++), private_data);
}
/*
called when a listening socket becomes readable.
*/
static void onefork_accept_connection(struct tevent_context *ev,
struct loadparm_context *lp_ctx,
struct socket_context *listen_socket,
void (*new_conn)(struct tevent_context *,
struct loadparm_context *, struct socket_context *,
struct server_id , void *),
void *private_data)
{
NTSTATUS status;
struct socket_context *connected_socket;
pid_t pid = getpid();
/* accept an incoming connection. */
status = socket_accept(listen_socket, &connected_socket);
if (!NT_STATUS_IS_OK(status)) {
return;
}
talloc_steal(private_data, connected_socket);
new_conn(ev, lp_ctx, connected_socket, cluster_id(pid, socket_get_fd(connected_socket)), private_data);
}
/*
called when a listening socket becomes readable.
*/
static void standard_accept_connection(struct tevent_context *ev,
struct loadparm_context *lp_ctx,
struct socket_context *sock,
void (*new_conn)(struct tevent_context *,
struct loadparm_context *, struct socket_context *,
struct server_id , void *),
void *private_data)
{
NTSTATUS status;
struct socket_context *sock2;
pid_t pid;
struct socket_address *c, *s;
struct standard_child_state *state;
struct tevent_fd *fde = NULL;
struct tevent_signal *se = NULL;
state = setup_standard_child_pipe(ev, NULL);
if (state == NULL) {
return;
}
/* accept an incoming connection. */
status = socket_accept(sock, &sock2);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("standard_accept_connection: accept: %s\n",
nt_errstr(status)));
/* this looks strange, but is correct. We need to throttle things until
the system clears enough resources to handle this new socket */
sleep(1);
close(state->to_parent_fd);
state->to_parent_fd = -1;
TALLOC_FREE(state);
return;
}
pid = fork();
if (pid != 0) {
close(state->to_parent_fd);
state->to_parent_fd = -1;
if (pid > 0) {
state->pid = pid;
} else {
TALLOC_FREE(state);
}
/* parent or error code ... */
talloc_free(sock2);
/* go back to the event loop */
return;
}
/* this leaves state->to_parent_fd open */
TALLOC_FREE(state);
pid = getpid();
/* This is now the child code. We need a completely new event_context to work with */
if (tevent_re_initialise(ev) != 0) {
smb_panic("Failed to re-initialise tevent after fork");
}
/* this will free all the listening sockets and all state that
is not associated with this new connection */
talloc_free(sock);
/* we don't care if the dup fails, as its only a select()
speed optimisation */
socket_dup(sock2);
/* tdb needs special fork handling */
ldb_wrap_fork_hook();
/* Must be done after a fork() to reset messaging contexts. */
status = imessaging_reinit_all();
if (!NT_STATUS_IS_OK(status)) {
smb_panic("Failed to re-initialise imessaging after fork");
}
fde = tevent_add_fd(ev, ev, child_pipe[0], TEVENT_FD_READ,
standard_pipe_handler, NULL);
if (fde == NULL) {
smb_panic("Failed to add fd handler after fork");
}
if (child_pipe[1] != -1) {
close(child_pipe[1]);
child_pipe[1] = -1;
}
se = tevent_add_signal(ev,
ev,
SIGHUP,
0,
sighup_signal_handler,
NULL);
if (se == NULL) {
smb_panic("Failed to add SIGHUP handler after fork");
}
se = tevent_add_signal(ev,
ev,
SIGTERM,
0,
sigterm_signal_handler,
NULL);
if (se == NULL) {
smb_panic("Failed to add SIGTERM handler after fork");
}
/* setup the process title */
c = socket_get_peer_addr(sock2, ev);
s = socket_get_my_addr(sock2, ev);
if (s && c) {
setproctitle("conn c[%s:%u] s[%s:%u] server_id[%d]",
c->addr, c->port, s->addr, s->port, (int)pid);
}
talloc_free(c);
talloc_free(s);
/* setup this new connection. Cluster ID is PID based for this process model */
new_conn(ev, lp_ctx, sock2, cluster_id(pid, 0), private_data);
/* we can't return to the top level here, as that event context is gone,
so we now process events in the new event context until there are no
more to process */
tevent_loop_wait(ev);
talloc_free(ev);
exit(0);
}
/*
called when a listening socket becomes readable.
*/
static void standard_accept_connection(struct tevent_context *ev,
struct loadparm_context *lp_ctx,
struct socket_context *sock,
void (*new_conn)(struct tevent_context *,
struct loadparm_context *, struct socket_context *,
struct server_id , void *),
void *private_data)
{
NTSTATUS status;
struct socket_context *sock2;
pid_t pid;
struct socket_address *c, *s;
/* accept an incoming connection. */
status = socket_accept(sock, &sock2);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("standard_accept_connection: accept: %s\n",
nt_errstr(status)));
/* this looks strange, but is correct. We need to throttle things until
the system clears enough resources to handle this new socket */
sleep(1);
return;
}
pid = fork();
if (pid != 0) {
/* parent or error code ... */
talloc_free(sock2);
/* go back to the event loop */
return;
}
pid = getpid();
/* This is now the child code. We need a completely new event_context to work with */
if (tevent_re_initialise(ev) != 0) {
smb_panic("Failed to re-initialise tevent after fork");
}
/* this will free all the listening sockets and all state that
is not associated with this new connection */
talloc_free(sock);
/* we don't care if the dup fails, as its only a select()
speed optimisation */
socket_dup(sock2);
/* tdb needs special fork handling */
ldb_wrap_fork_hook();
tevent_add_fd(ev, ev, child_pipe[0], TEVENT_FD_READ,
standard_pipe_handler, NULL);
close(child_pipe[1]);
/* Ensure that the forked children do not expose identical random streams */
set_need_random_reseed();
/* setup the process title */
c = socket_get_peer_addr(sock2, ev);
s = socket_get_my_addr(sock2, ev);
if (s && c) {
setproctitle("conn c[%s:%u] s[%s:%u] server_id[%d]",
c->addr, c->port, s->addr, s->port, (int)pid);
}
talloc_free(c);
talloc_free(s);
/* setup this new connection. Cluster ID is PID based for this process model */
new_conn(ev, lp_ctx, sock2, cluster_id(pid, 0), private_data);
/* we can't return to the top level here, as that event context is gone,
so we now process events in the new event context until there are no
more to process */
tevent_loop_wait(ev);
talloc_free(ev);
exit(0);
}
pair<int, int> haplotypeCluster::kmeans(unsigned int cluster,
unsigned int depth) {
int nchanged = 0;
int debug = 0;
if (_DEBUG > 1)
cout << "Clustering (K-means) K = " << K << ". NSNP = " << nsnp << endl;
pair<unsigned int, unsigned int> cluster_id(cluster, cluster + pow(2, depth));
int N = 0;
for (int i = 0; i < nhap; i++) {
if (clustering[i] == cluster) {
cluster_mask[i] = true;
N++;
} else
cluster_mask[i] = false;
}
mu.assign(K, vector<float>(nsnp, -1));
dlook.resize(K);
pair<int, int> cluster_size;
vector<float> d(K);
vector<float> tmp(nsnp);
float ss;
// kplusplus(K,tmp2,initial_centroids);
int idx1 = getIdx(putils::getRandom(N));
int idx2 = getIdx(putils::getRandom(N));
float maxdist = g->vecH[idx1].hamming(g->vecH[idx2], cstart, cstop);
for (int i = 0; i < 100; i++) {
int tmp1 = getIdx(putils::getRandom(N));
float tmp2 = g->vecH[idx1].hamming(g->vecH[tmp1], cstart, cstop);
if (tmp2 > maxdist) {
idx2 = tmp1;
maxdist = tmp2;
}
}
for (int j = 0; j < nsnp; j++) {
mu[0][j] = (float)(g->vecH[idx1][cstart + j]);
mu[1][j] = (float)(g->vecH[idx2][cstart + j]);
}
if (_DEBUG > 1) {
printmu(mu);
cout << endl;
}
int closest_cluster;
// LLOYDS ALGORITHM - standard K-means routine
for (int iteration = 0; iteration < niteration; iteration++) {
nchanged = 0;
for (int i = 0; i < K; i++)
dlook[i].assign(nsnp / 8, vector<float>(256, -1.0));
ss = 0.0;
for (int i = 0; i < nhap; i++) {
if (cluster_mask[i]) {
for (int j = 0; j < K; j++)
d[j] = euc(i, j, mu, dlook);
if (d[0] < d[1]) {
ss += d[0];
closest_cluster = cluster_id.first;
} else {
ss += d[1];
closest_cluster = cluster_id.second;
}
if (clustering[i] != closest_cluster)
nchanged++;
clustering[i] = closest_cluster;
}
}
updateMeans(cluster_id, cluster_size);
if (_DEBUG > 1)
cout << "LLOYDS K-MEANS ITERATION " << iteration
<< " Mean SS = " << ss / (float)N << "\t" << nchanged
<< " haps changed clusters." << endl;
if (nchanged == 0)
break;
}
// if(_DEBUG>0) cout << "Lloyds Total SS = " << SS() << "\t"<<nchanged << "
// haps changed clusters on last iteration" << endl;
int minind = cluster_size.first > cluster_size.second;
int minsize = min(cluster_size.first, cluster_size.second);
if (minsize < ncond && K == 2) { // not partioning well. do a random split.
vector<pair<int, float> > closest;
if (_DEBUG > 0)
cout << "WARNING: " << N << " did not partition well. "
<< cluster_size.first << " " << cluster_size.second
<< ". Regrouping." << endl;
closestN(N / 2, minind, closest);
for (int j = 0; j < closest.size();
j++) { // change cluster of closet N2 guys.
if (minind == 0) {
clustering[closest[j].first] = cluster_id.first;
cluster_size.first++;
cluster_size.second--;
} else {
clustering[closest[j].first] = cluster_id.second;
cluster_size.first--;
cluster_size.second++;
}
}
}
return (cluster_size);
};
/*
* called to create a new server task
*/
static void prefork_new_task(
struct tevent_context *ev,
struct loadparm_context *lp_ctx,
const char *service_name,
void (*new_task_fn)(struct tevent_context *,
struct loadparm_context *lp_ctx,
struct server_id , void *, void *),
void *private_data,
const struct service_details *service_details,
int from_parent_fd)
{
pid_t pid;
struct tfork* t = NULL;
int i, num_children;
struct tevent_context *ev2;
t = tfork_create();
if (t == NULL) {
smb_panic("failure in tfork\n");
}
pid = tfork_child_pid(t);
if (pid != 0) {
struct tevent_fd *fde = NULL;
int fd = tfork_event_fd(t);
/* Register a pipe handler that gets called when the prefork
* master process terminates.
*/
fde = tevent_add_fd(ev, ev, fd, TEVENT_FD_READ,
prefork_child_pipe_handler, t);
if (fde == NULL) {
smb_panic("Failed to add child pipe handler, "
"after fork");
}
tevent_fd_set_auto_close(fde);
return;
}
pid = getpid();
setproctitle("task[%s] pre-fork master", service_name);
/*
* this will free all the listening sockets and all state that
* is not associated with this new connection
*/
if (tevent_re_initialise(ev) != 0) {
smb_panic("Failed to re-initialise tevent after fork");
}
prefork_reload_after_fork();
setup_handlers(ev, from_parent_fd);
if (service_details->inhibit_pre_fork) {
new_task_fn(ev, lp_ctx, cluster_id(pid, 0), private_data, NULL);
/* The task does not support pre-fork */
tevent_loop_wait(ev);
TALLOC_FREE(ev);
exit(0);
}
/*
* This is now the child code. We need a completely new event_context
* to work with
*/
ev2 = s4_event_context_init(NULL);
/* setup this new connection: process will bind to it's sockets etc
*
* While we can use ev for the child, which has been re-initialised
* above we must run the new task under ev2 otherwise the children would
* be listening on the sockets. Also we don't want the top level
* process accepting and handling requests, it's responsible for
* monitoring and controlling the child work processes.
*/
new_task_fn(ev2, lp_ctx, cluster_id(pid, 0), private_data, NULL);
{
int default_children;
default_children = lpcfg_prefork_children(lp_ctx);
num_children = lpcfg_parm_int(lp_ctx, NULL, "prefork children",
service_name, default_children);
}
if (num_children == 0) {
DBG_WARNING("Number of pre-fork children for %s is zero, "
"NO worker processes will be started for %s\n",
service_name, service_name);
}
DBG_NOTICE("Forking %d %s worker processes\n",
num_children, service_name);
/* We are now free to spawn some worker processes */
for (i=0; i < num_children; i++) {
struct tfork* w = NULL;
w = tfork_create();
if (w == NULL) {
smb_panic("failure in tfork\n");
}
pid = tfork_child_pid(w);
if (pid != 0) {
struct tevent_fd *fde = NULL;
int fd = tfork_event_fd(w);
fde = tevent_add_fd(ev, ev, fd, TEVENT_FD_READ,
prefork_child_pipe_handler, w);
if (fde == NULL) {
smb_panic("Failed to add child pipe handler, "
"after fork");
}
tevent_fd_set_auto_close(fde);
} else {
/* tfork uses malloc */
free(w);
TALLOC_FREE(ev);
setproctitle("task[%s] pre-forked worker",
service_name);
prefork_reload_after_fork();
setup_handlers(ev2, from_parent_fd);
tevent_loop_wait(ev2);
talloc_free(ev2);
exit(0);
}
}
/* Don't listen on the sockets we just gave to the children */
tevent_loop_wait(ev);
TALLOC_FREE(ev);
/* We need to keep ev2 until we're finished for the messaging to work */
TALLOC_FREE(ev2);
exit(0);
}
/*
called to create a new server task
*/
static void standard_new_task(struct tevent_context *ev,
struct loadparm_context *lp_ctx,
const char *service_name,
void (*new_task)(struct tevent_context *, struct loadparm_context *lp_ctx, struct server_id , void *),
void *private_data)
{
pid_t pid;
NTSTATUS status;
struct standard_child_state *state;
struct tevent_fd *fde = NULL;
struct tevent_signal *se = NULL;
state = setup_standard_child_pipe(ev, service_name);
if (state == NULL) {
return;
}
pid = fork();
if (pid != 0) {
close(state->to_parent_fd);
state->to_parent_fd = -1;
if (pid > 0) {
state->pid = pid;
} else {
TALLOC_FREE(state);
}
/* parent or error code ... go back to the event loop */
return;
}
/* this leaves state->to_parent_fd open */
TALLOC_FREE(state);
pid = getpid();
/* this will free all the listening sockets and all state that
is not associated with this new connection */
if (tevent_re_initialise(ev) != 0) {
smb_panic("Failed to re-initialise tevent after fork");
}
/* ldb/tdb need special fork handling */
ldb_wrap_fork_hook();
/* Must be done after a fork() to reset messaging contexts. */
status = imessaging_reinit_all();
if (!NT_STATUS_IS_OK(status)) {
smb_panic("Failed to re-initialise imessaging after fork");
}
fde = tevent_add_fd(ev, ev, child_pipe[0], TEVENT_FD_READ,
standard_pipe_handler, NULL);
if (fde == NULL) {
smb_panic("Failed to add fd handler after fork");
}
if (child_pipe[1] != -1) {
close(child_pipe[1]);
child_pipe[1] = -1;
}
se = tevent_add_signal(ev,
ev,
SIGHUP,
0,
sighup_signal_handler,
NULL);
if (se == NULL) {
smb_panic("Failed to add SIGHUP handler after fork");
}
se = tevent_add_signal(ev,
ev,
SIGTERM,
0,
sigterm_signal_handler,
NULL);
if (se == NULL) {
smb_panic("Failed to add SIGTERM handler after fork");
}
setproctitle("task %s server_id[%d]", service_name, (int)pid);
/* setup this new task. Cluster ID is PID based for this process model */
new_task(ev, lp_ctx, cluster_id(pid, 0), private_data);
/* we can't return to the top level here, as that event context is gone,
so we now process events in the new event context until there are no
more to process */
tevent_loop_wait(ev);
talloc_free(ev);
exit(0);
}
/*
called when a listening socket becomes readable.
*/
static void standard_accept_connection(struct tevent_context *ev,
struct loadparm_context *lp_ctx,
struct socket_context *sock,
void (*new_conn)(struct tevent_context *,
struct loadparm_context *, struct socket_context *,
struct server_id , void *),
void *private_data)
{
NTSTATUS status;
struct socket_context *sock2;
pid_t pid;
struct tevent_context *ev2;
struct socket_address *c, *s;
/* accept an incoming connection. */
status = socket_accept(sock, &sock2);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("standard_accept_connection: accept: %s\n",
nt_errstr(status)));
/* this looks strange, but is correct. We need to throttle things until
the system clears enough resources to handle this new socket */
sleep(1);
return;
}
pid = fork();
if (pid != 0) {
/* parent or error code ... */
talloc_free(sock2);
/* go back to the event loop */
return;
}
pid = getpid();
/* This is now the child code. We need a completely new event_context to work with */
ev2 = s4_event_context_init(NULL);
/* the service has given us a private pointer that
encapsulates the context it needs for this new connection -
everything else will be freed */
talloc_steal(ev2, private_data);
talloc_steal(private_data, sock2);
/* this will free all the listening sockets and all state that
is not associated with this new connection */
talloc_free(sock);
talloc_free(ev);
/* we don't care if the dup fails, as its only a select()
speed optimisation */
socket_dup(sock2);
/* tdb needs special fork handling */
if (tdb_reopen_all(1) == -1) {
DEBUG(0,("standard_accept_connection: tdb_reopen_all failed.\n"));
}
/* Ensure that the forked children do not expose identical random streams */
set_need_random_reseed();
/* setup the process title */
c = socket_get_peer_addr(sock2, ev2);
s = socket_get_my_addr(sock2, ev2);
if (s && c) {
setproctitle("conn c[%s:%u] s[%s:%u] server_id[%d]",
c->addr, c->port, s->addr, s->port, pid);
}
talloc_free(c);
talloc_free(s);
/* setup this new connection. Cluster ID is PID based for this process modal */
new_conn(ev2, lp_ctx, sock2, cluster_id(pid, 0), private_data);
/* we can't return to the top level here, as that event context is gone,
so we now process events in the new event context until there are no
more to process */
event_loop_wait(ev2);
talloc_free(ev2);
exit(0);
}
/*
test ping speed
*/
static bool test_ping_speed(struct torture_context *tctx)
{
struct tevent_context *ev;
struct messaging_context *msg_client_ctx;
struct messaging_context *msg_server_ctx;
int ping_count = 0;
int pong_count = 0;
struct timeval tv;
int timelimit = torture_setting_int(tctx, "timelimit", 10);
uint32_t msg_ping, msg_exit;
lp_set_cmdline(tctx->lp_ctx, "pid directory", "piddir.tmp");
ev = tctx->ev;
msg_server_ctx = messaging_init(tctx,
lp_messaging_path(tctx, tctx->lp_ctx),
cluster_id(0, 1),
lp_iconv_convenience(tctx->lp_ctx),
ev);
torture_assert(tctx, msg_server_ctx != NULL, "Failed to init ping messaging context");
messaging_register_tmp(msg_server_ctx, NULL, ping_message, &msg_ping);
messaging_register_tmp(msg_server_ctx, tctx, exit_message, &msg_exit);
msg_client_ctx = messaging_init(tctx,
lp_messaging_path(tctx, tctx->lp_ctx),
cluster_id(0, 2),
lp_iconv_convenience(tctx->lp_ctx),
ev);
torture_assert(tctx, msg_client_ctx != NULL,
"msg_client_ctx messaging_init() failed");
messaging_register_tmp(msg_client_ctx, &pong_count, pong_message, &msg_pong);
tv = timeval_current();
torture_comment(tctx, "Sending pings for %d seconds\n", timelimit);
while (timeval_elapsed(&tv) < timelimit) {
DATA_BLOB data;
NTSTATUS status1, status2;
data.data = discard_const_p(uint8_t, "testing");
data.length = strlen((const char *)data.data);
status1 = messaging_send(msg_client_ctx, cluster_id(0, 1), msg_ping, &data);
status2 = messaging_send(msg_client_ctx, cluster_id(0, 1), msg_ping, NULL);
torture_assert_ntstatus_ok(tctx, status1, "msg1 failed");
ping_count++;
torture_assert_ntstatus_ok(tctx, status2, "msg2 failed");
ping_count++;
while (ping_count > pong_count + 20) {
event_loop_once(ev);
}
}
torture_comment(tctx, "waiting for %d remaining replies (done %d)\n",
ping_count - pong_count, pong_count);
while (timeval_elapsed(&tv) < 30 && pong_count < ping_count) {
event_loop_once(ev);
}
torture_comment(tctx, "sending exit\n");
messaging_send(msg_client_ctx, cluster_id(0, 1), msg_exit, NULL);
torture_assert_int_equal(tctx, ping_count, pong_count, "ping test failed");
torture_comment(tctx, "ping rate of %.0f messages/sec\n",
(ping_count+pong_count)/timeval_elapsed(&tv));
talloc_free(msg_client_ctx);
talloc_free(msg_server_ctx);
return true;
}
int
main (int argc, char ** argv)
{
if (argc < 2)
{
pcl::console::print_info ("Syntax is: %s input.pcd <options>\n", argv[0]);
pcl::console::print_info (" where options are:\n");
pcl::console::print_info (" -p dist_threshold,max_iters ..... Subtract the dominant plane\n");
pcl::console::print_info (" -c tolerance,min_size,max_size ... Cluster points\n");
pcl::console::print_info (" -s output.pcd .................... Save the largest cluster\n");
return (1);
}
// Load the input file
PointCloudPtr cloud (new PointCloud);
pcl::io::loadPCDFile (argv[1], *cloud);
pcl::console::print_info ("Loaded %s (%zu points)\n", argv[1], cloud->size ());
// Subtract the dominant plane
double dist_threshold, max_iters;
bool subtract_plane = pcl::console::parse_2x_arguments (argc, argv, "-p", dist_threshold, max_iters) > 0;
if (subtract_plane)
{
size_t n = cloud->size ();
cloud = findAndSubtractPlane (cloud, dist_threshold, (int)max_iters);
pcl::console::print_info ("Subtracted %zu points along the detected plane\n", n - cloud->size ());
}
// Cluster points
double tolerance, min_size, max_size;
std::vector<pcl::PointIndices> cluster_indices;
bool cluster_points = pcl::console::parse_3x_arguments (argc, argv, "-c", tolerance, min_size, max_size) > 0;
if (cluster_points)
{
clusterObjects (cloud, tolerance, (int)min_size, (int)max_size, cluster_indices);
pcl::console::print_info ("Found %zu clusters\n", cluster_indices.size ());
}
// Save output
std::string output_filename;
bool save_cloud = pcl::console::parse_argument (argc, argv, "-s", output_filename) > 0;
if (save_cloud)
{
// If clustering was performed, save only the first (i.e., largest) cluster
if (cluster_points)
{
PointCloudPtr temp_cloud (new PointCloud);
pcl::copyPointCloud (*cloud, cluster_indices[0], *temp_cloud);
cloud = temp_cloud;
}
pcl::console::print_info ("Saving result as %s...\n", output_filename.c_str ());
pcl::io::savePCDFile (output_filename, *cloud);
}
// Or visualize the result
else
{
pcl::console::print_info ("Starting visualizer... Close window to exit.\n");
pcl::visualization::PCLVisualizer vis;
// If clustering was performed, display each cluster with a random color
if (cluster_points)
{
for (size_t i = 0; i < cluster_indices.size (); ++i)
{
// Extract the i_th cluster into a new cloud
pcl::PointCloud<pcl::PointXYZ>::Ptr cluster_i (new pcl::PointCloud<pcl::PointXYZ>);
pcl::copyPointCloud (*cloud, cluster_indices[i], *cluster_i);
// Create a random color
pcl::visualization::PointCloudColorHandlerRandom<pcl::PointXYZ> random_color (cluster_i);
// Create a unique identifier
std::stringstream cluster_id ("cluster");
cluster_id << i;
// Add the i_th cluster to the visualizer with a random color and a unique identifier
vis.addPointCloud<pcl::PointXYZ> (cluster_i, random_color, cluster_id.str ());
}
}
else
{
// If clustering wasn't performed, just display the cloud
vis.addPointCloud (cloud);
}
vis.resetCamera ();
vis.spin ();
}
return (0);
}
static bool test_messaging_overflow(struct torture_context *tctx)
{
struct imessaging_context *msg_ctx;
ssize_t nwritten, nread;
pid_t child;
char c = 0;
int up_pipe[2], down_pipe[2];
int i, ret, child_status;
ret = pipe(up_pipe);
torture_assert(tctx, ret == 0, "pipe failed");
ret = pipe(down_pipe);
torture_assert(tctx, ret == 0, "pipe failed");
child = fork();
if (child < 0) {
torture_fail(tctx, "fork failed");
}
if (child == 0) {
ret = tevent_re_initialise(tctx->ev);
torture_assert(tctx, ret == 0, "tevent_re_initialise failed");
msg_ctx = imessaging_init(tctx, tctx->lp_ctx,
cluster_id(getpid(), 0),
tctx->ev);
torture_assert(tctx, msg_ctx != NULL,
"imessaging_init failed");
do {
nwritten = write(up_pipe[1], &c, 1);
} while ((nwritten == -1) && (errno == EINTR));
ret = close(down_pipe[1]);
torture_assert(tctx, ret == 0, "close failed");
do {
nread = read(down_pipe[0], &c, 1);
} while ((nread == -1) && (errno == EINTR));
exit(0);
}
do {
nread = read(up_pipe[0], &c, 1);
} while ((nread == -1) && (errno == EINTR));
msg_ctx = imessaging_init(tctx, tctx->lp_ctx, cluster_id(getpid(), 0),
tctx->ev);
torture_assert(tctx, msg_ctx != NULL, "imessaging_init failed");
for (i=0; i<1000; i++) {
NTSTATUS status;
status = imessaging_send(msg_ctx, cluster_id(child, 0),
MSG_PING, NULL);
torture_assert_ntstatus_ok(tctx, status,
"imessaging_send failed");
}
tevent_loop_once(tctx->ev);
talloc_free(msg_ctx);
ret = close(down_pipe[1]);
torture_assert(tctx, ret == 0, "close failed");
ret = waitpid(child, &child_status, 0);
torture_assert(tctx, ret == child, "wrong child exited");
torture_assert(tctx, child_status == 0, "child failed");
poll(NULL, 0, 500);
return true;
}
