/**
* oh_ssl_init
*
* Intialize the OpenSSL library. Note that the calls used in this routine
* set up global data and are only to be called once for an SSL-based program.
* To enforce this while allowing multiple callers (plugins) to initialize
* the library, we use a static global variable to mark when we've done the
* initialization.
*
* Note that the thread-safe initialization portion requires that
* g_thread_init() has already been called, so don't call this routine
* before then.
*
* Return value: 0 for success, -1 for failure
**/
int oh_ssl_init(void)
{
if (! oh_ssl_init_done) { /* Do this only once */
oh_ssl_init_done = 1;
/* Load error strings to provide human-readable error
* messages
*/
SSL_load_error_strings();
ERR_load_BIO_strings();
/* Initialize the SSL library */
if (! SSL_library_init()) {
err("SSL_library_init() failed");
return(-1);
}
#ifndef NO_SSL_RAND_SEED /* In case this isn't portable */
/* Actions to seed PRNG */
RAND_load_file("/dev/urandom", 1024);
#endif
/* Set up multi-thread protection functions */
if (thread_setup() ) {
err("SSL multi-thread protection setup call failed");
return(-1);
}
}
return(0); /* Successful return */
}
/**
* oh_ssl_init
*
* Intialize the OpenSSL library. Note that the calls used in this routine
* set up global data and are only to be called once for an SSL-based program.
* To enforce this while allowing multiple callers (plugins) to initialize
* the library, we use a static global variable to mark when we've done the
* initialization.
*
* Return value: 0 for success, -1 for failure
**/
int oh_ssl_init(void)
{
if (! oh_ssl_init_done) { /* Do this only once */
oh_ssl_init_done = 1;
/* Load error strings to provide human-readable error
* messages
*/
SSL_load_error_strings();
ERR_load_BIO_strings();
/* Initialize the SSL library */
if (! SSL_library_init()) {
err("SSL_library_init() failed");
return(-1);
}
/* Actions to seed PRNG */
RAND_load_file("/dev/urandom", 1024);
/* Set up multi-thread protection functions */
if (thread_setup() ) {
err("SSL multi-thread protection setup call failed");
return(-1);
}
}
return(0); /* Cannot currently fail */
}
bool downloadS3(const char *urlWithOptions) {
if (!urlWithOptions) {
return false;
}
int data_len = BUF_SIZE;
char data_buf[BUF_SIZE];
bool ret = true;
thread_setup();
GPReader *reader = reader_init(urlWithOptions);
if (!reader) {
return false;
}
do {
data_len = BUF_SIZE;
if (!reader_transfer_data(reader, data_buf, data_len)) {
fprintf(stderr, "Failed to read data from Amazon S3\n");
ret = false;
break;
}
fwrite(data_buf, (size_t)data_len, 1, stdout);
} while (data_len && !S3QueryIsAbortInProgress());
reader_cleanup(&reader);
thread_cleanup();
return ret;
}
void init_ssl(void) {
SSL_library_init();
OpenSSL_add_all_algorithms(); /* load & register cryptos */
SSL_load_error_strings(); /* load all error messages */
ws_globals.ssl_method = SSLv23_server_method(); /* create server instance */
ws_globals.ssl_ctx = SSL_CTX_new(ws_globals.ssl_method); /* create context */
assert(ws_globals.ssl_ctx);
/* Disable SSLv2 */
SSL_CTX_set_options(globals.ssl_ctx, SSL_OP_NO_SSLv2);
/* Disable SSLv3 */
SSL_CTX_set_options(globals.ssl_ctx, SSL_OP_NO_SSLv3);
/* Disable TLSv1 */
SSL_CTX_set_options(globals.ssl_ctx, SSL_OP_NO_TLSv1);
/* Disable Compression CRIME (Compression Ratio Info-leak Made Easy) */
SSL_CTX_set_options(globals.ssl_ctx, SSL_OP_NO_COMPRESSION);
/* set the local certificate from CertFile */
SSL_CTX_use_certificate_file(ws_globals.ssl_ctx, ws_globals.cert, SSL_FILETYPE_PEM);
/* set the private key from KeyFile */
SSL_CTX_use_PrivateKey_file(ws_globals.ssl_ctx, ws_globals.key, SSL_FILETYPE_PEM);
/* verify private key */
if ( !SSL_CTX_check_private_key(ws_globals.ssl_ctx) ) {
abort();
}
SSL_CTX_set_cipher_list(ws_globals.ssl_ctx, "HIGH:!DSS:!aNULL@STRENGTH");
thread_setup();
}
// Initialize library.
// To be called once during the lifetime of the app.
// $package: The folder where the package data resides.
// $webroot: The document root folder for the web server.
void bibledit_initialize_library (const char * package, const char * webroot)
{
// Must initialize libcurl before any threads are started.
#ifdef HAVE_CLIENT
#else
curl_global_init (CURL_GLOBAL_ALL);
#endif
// Thread locking.
thread_setup ();
// Initialize SQLite: Full thread safety: https://www.sqlite.org/c3ref/threadsafe.html.
// This is supported to prevent "database locked" errors.
if (!sqlite3_threadsafe ()) {
cerr << "SQLite is not threadsafe" << endl;
}
sqlite3_config (SQLITE_CONFIG_SERIALIZED);
// Binary file mode on Windows.
#ifdef HAVE_WINDOWS
_set_fmode (_O_BINARY);
#endif
// Set the web root folder.
config_globals_document_root = webroot;
// Initialize SSL/TLS (after webroot has been set).
filter_url_ssl_tls_initialize ();
#ifndef HAVE_CLIENT
// Cloud initializes OpenLDAP server access settings (after webroot has been set).
ldap_logic_initialize ();
#endif
#ifdef HAVE_CLIENT
// Set local timezone offset in the library.
#ifdef HAVE_WINDOWS
TIME_ZONE_INFORMATION tzi;
DWORD dwRet = GetTimeZoneInformation (&tzi);
(void)dwRet;
int offset = 0 - (tzi.Bias / 60);
bibledit_set_timezone_hours_offset_utc (offset);
#else
time_t t = time (NULL);
struct tm lt = {};
localtime_r (&t, <);
int offset = round (lt.tm_gmtoff / 3600);
bibledit_set_timezone_hours_offset_utc (offset);
#endif
#endif
// Initialize data in a thread.
thread setup_thread = thread (setup_conditionally, package);
setup_thread.detach ();
// Multiple start/stop guard.
bibledit_started = false;
}
void *
second_thread(void *args)
{
struct second_thread_args *secargs = (struct second_thread_args *)args;
int res;
uint64_t i;
kern_return_t kret;
uint64_t wake_time;
int cpuno;
/* Set scheduling policy */
res = thread_setup(secargs->pol);
if (res != 0) {
printf("Couldn't set thread policy.\n");
exit(1);
}
/*
* Repeatedly pick a random timer length and
* try to sleep exactly that long
*/
for (i = 0; i < secargs->iterations; i++) {
/* Wake up when poked by main thread */
kret = semaphore_wait(secargs->wakeup_semaphore);
if (kret != KERN_SUCCESS) {
errx(1, "semaphore_wait %d", kret);
}
wake_time = mach_absolute_time();
cpuno = cpu_number();
if (wake_time < secargs->last_poke_time) {
/* Woke in past, unsynchronized mach_absolute_time()? */
errx(1, "woke in past %llu (%d) < %llu (%d)", wake_time, cpuno, secargs->last_poke_time, secargs->cpuno);
}
if (cpuno == secargs->cpuno) {
secargs->woke_on_same_cpu++;
}
secargs->wakeup_second_jitter_arr[i] = (double)(wake_time - secargs->last_poke_time);
/* Too much: cut a tracepoint for a debugger */
if (secargs->wakeup_second_jitter_arr[i] >= secargs->too_much) {
kdebug_trace(0xeeeee4 | DBG_FUNC_NONE, 0, 0, 0, 0);
}
kret = semaphore_signal(secargs->return_semaphore);
if (kret != KERN_SUCCESS) {
errx(1, "semaphore_signal %d", kret);
}
}
return NULL;
}
/*
* Export data out of GPDB.
* invoked by GPDB, be careful with C++ exceptions.
*/
Datum s3_export(PG_FUNCTION_ARGS) {
/* Must be called via the external table format manager */
if (!CALLED_AS_EXTPROTOCOL(fcinfo))
elog(ERROR, "extprotocol_import: not called by external protocol manager");
/* Get our internal description of the protocol */
GPWriter *gpwriter = (GPWriter *)EXTPROTOCOL_GET_USER_CTX(fcinfo);
/* last call. destroy writer */
if (EXTPROTOCOL_IS_LAST_CALL(fcinfo)) {
thread_cleanup();
if (!writer_cleanup(&gpwriter)) {
ereport(ERROR,
(0, errmsg("Failed to cleanup S3 extension: %s", s3extErrorMessage.c_str())));
}
EXTPROTOCOL_SET_USER_CTX(fcinfo, NULL);
PG_RETURN_INT32(0);
}
/* first call. do any desired init */
if (gpwriter == NULL) {
const char *url_with_options = EXTPROTOCOL_GET_URL(fcinfo);
const char *format = get_format_str(fcinfo);
thread_setup();
gpwriter = writer_init(url_with_options, format);
if (!gpwriter) {
ereport(ERROR, (0, errmsg("Failed to init S3 extension, segid = %d, "
"segnum = %d, please check your "
"configurations and net connection: %s",
s3ext_segid, s3ext_segnum, s3extErrorMessage.c_str())));
}
EXTPROTOCOL_SET_USER_CTX(fcinfo, gpwriter);
}
char *data_buf = EXTPROTOCOL_GET_DATABUF(fcinfo);
int32 data_len = EXTPROTOCOL_GET_DATALEN(fcinfo);
if (!writer_transfer_data(gpwriter, data_buf, data_len)) {
ereport(ERROR,
(0, errmsg("s3_export: could not write data: %s", s3extErrorMessage.c_str())));
}
PG_RETURN_INT32(data_len);
}
bool uploadS3(const char *urlWithOptions, const char *fileToUpload) {
if (!urlWithOptions) {
return false;
}
size_t data_len = BUF_SIZE;
char data_buf[BUF_SIZE];
size_t read_len = 0;
bool ret = true;
thread_setup();
GPWriter *writer = writer_init(urlWithOptions);
if (!writer) {
return false;
}
FILE *fd = fopen(fileToUpload, "r");
if (fd == NULL) {
fprintf(stderr, "File does not exist\n");
ret = false;
} else {
do {
read_len = fread(data_buf, 1, data_len, fd);
if (read_len == 0) {
break;
}
if (!writer_transfer_data(writer, data_buf, (int)read_len)) {
fprintf(stderr, "Failed to write data to Amazon S3\n");
ret = false;
break;
}
} while (read_len == data_len && !S3QueryIsAbortInProgress());
if (ferror(fd)) {
ret = false;
}
fclose(fd);
}
writer_cleanup(&writer);
thread_cleanup();
return ret;
}
void do_test(void)
{
thread_setup(&a_thr, (reg_t) a_thread, SP(a_stack));
thread_setup(&b_thr, (reg_t) b_thread, SP(b_stack));
thread_setup(&c_thr, (reg_t) c_thread, SP(c_stack));
initrd_thrs[INITRD_APPS-1].next = &a_thr;
a_thr.next = &b_thr;
b_thr.next = &c_thr;
c_thr.next = &initrd_thrs[0];
CAP_TCB(&a_thr, 1) = &initrd_thrs[0];//ipc server /usr/wtest
CAP_TCB(&b_thr, 1) = &initrd_thrs[0];//ipc server /usr/wtest
CAP_TCB(&c_thr, 1) = &initrd_thrs[0];//ipc server /usr/wtest
CAP_TCB(&a_thr, 0) = &idle_thr;//ipc server idle
CAP_TCB(&b_thr, 0) = &idle_thr;//ipc server idle
CAP_TCB(&c_thr, 0) = &idle_thr;//ipc server idle
CAP_TCB(&c_thr, 2) = &initrd_thrs[5];//fault server /dev/ata
thread_switch(&initrd_thrs[4]);//fault server /dev/fd0
ad_t vir = 0x80000000, phy = 0x100000;
printstr("/dev/fd0: server mem v_map to fd0mem...");
for (int i = 0; i < 0x168; i++) {
/*printstr("v_map(vir=");
printint(vir);
printstr(", phy=");
printint(phy);
printstr(")\n");*/
v_map(vir, phy, PG_W | PG_U);
vir += PGSIZE;
phy += PGSIZE;
}
printstr("done\n");
/*printstr("/svr/fat: set mem server (cid 2) to /dev/fd0\n");
CAP_TCB(&initrd_thrs[5], 2) = &initrd_thrs[4];//fault server /dev/fd0*/
thread_switch(&initrd_thrs[5]);//fault server /dev/ata
}
static void openssl_init()
{
static bool initialized = false;
if (!initialized)
{
cxxtools::MutexLock lock(mutex);
if (!initialized)
{
log_debug("SSL_load_error_strings");
SSL_load_error_strings();
log_debug("SSL_library_init");
SSL_library_init();
checkSslError();
thread_setup();
initialized = true;
}
}
}
static void
platform_hardware_setup(void)
{
// Make sure legacy DMA isn't running.
dma_setup();
// Init base pc hardware.
pic_setup();
thread_setup();
mathcp_setup();
// Platform specific setup
qemu_platform_setup();
coreboot_platform_setup();
// Setup timers and periodic clock interrupt
timer_setup();
clock_setup();
// Initialize TPM
tpm_setup();
}
void init_ssl(void) {
SSL_library_init();
OpenSSL_add_all_algorithms(); /* load & register cryptos */
SSL_load_error_strings(); /* load all error messages */
ws_globals.ssl_method = TLSv1_server_method(); /* create server instance */
ws_globals.ssl_ctx = SSL_CTX_new(ws_globals.ssl_method); /* create context */
assert(ws_globals.ssl_ctx);
/* set the local certificate from CertFile */
SSL_CTX_use_certificate_file(ws_globals.ssl_ctx, ws_globals.cert, SSL_FILETYPE_PEM);
/* set the private key from KeyFile */
SSL_CTX_use_PrivateKey_file(ws_globals.ssl_ctx, ws_globals.key, SSL_FILETYPE_PEM);
/* verify private key */
if ( !SSL_CTX_check_private_key(ws_globals.ssl_ctx) ) {
abort();
}
SSL_CTX_set_cipher_list(ws_globals.ssl_ctx, "HIGH:!DSS:!aNULL@STRENGTH");
thread_setup();
}
int
main(int argc, char **argv)
{
uint64_t iterations, i;
double *jitter_arr, *fraction_arr;
double *wakeup_second_jitter_arr;
uint64_t target_time;
uint64_t sleep_length_abs;
uint64_t min_sleep_ns = 0;
uint64_t max_sleep_ns = DEFAULT_MAX_SLEEP_NS;
uint64_t wake_time;
unsigned random_seed;
boolean_t need_seed = TRUE;
char ch;
int res;
kern_return_t kret;
my_policy_type_t pol;
boolean_t wakeup_second_thread = FALSE;
semaphore_t wakeup_semaphore, return_semaphore;
double avg, stddev, max, min;
double avg_fract, stddev_fract, max_fract, min_fract;
uint64_t too_much;
struct second_thread_args secargs;
pthread_t secthread;
mach_timebase_info(&g_mti);
/* Seed random */
opterr = 0;
while ((ch = getopt(argc, argv, "m:n:hs:w")) != -1 && ch != '?') {
switch (ch) {
case 's':
/* Specified seed for random)() */
random_seed = (unsigned)atoi(optarg);
srandom(random_seed);
need_seed = FALSE;
break;
case 'm':
/* How long per timer? */
max_sleep_ns = strtoull(optarg, NULL, 10);
break;
case 'n':
/* How long per timer? */
min_sleep_ns = strtoull(optarg, NULL, 10);
break;
case 'w':
/* After each timed wait, wakeup another thread */
wakeup_second_thread = TRUE;
break;
case 'h':
print_usage();
exit(0);
break;
default:
fprintf(stderr, "Got unexpected result from getopt().\n");
exit(1);
break;
}
}
argc -= optind;
argv += optind;
if (argc != 3) {
print_usage();
exit(1);
}
if (min_sleep_ns >= max_sleep_ns) {
print_usage();
exit(1);
}
if (need_seed) {
srandom(time(NULL));
}
/* What scheduling policy? */
pol = parse_thread_policy(argv[0]);
/* How many timers? */
iterations = strtoull(argv[1], NULL, 10);
/* How much jitter is so extreme that we should cut a trace point */
too_much = strtoull(argv[2], NULL, 10);
/* Array for data */
jitter_arr = (double*)malloc(sizeof(*jitter_arr) * iterations);
if (jitter_arr == NULL) {
printf("Couldn't allocate array to store results.\n");
exit(1);
}
fraction_arr = (double*)malloc(sizeof(*fraction_arr) * iterations);
if (fraction_arr == NULL) {
printf("Couldn't allocate array to store results.\n");
exit(1);
}
if (wakeup_second_thread) {
/* Array for data */
wakeup_second_jitter_arr = (double*)malloc(sizeof(*jitter_arr) * iterations);
if (wakeup_second_jitter_arr == NULL) {
printf("Couldn't allocate array to store results.\n");
exit(1);
}
kret = semaphore_create(mach_task_self(), &wakeup_semaphore, SYNC_POLICY_FIFO, 0);
if (kret != KERN_SUCCESS) {
printf("Couldn't allocate semaphore %d\n", kret);
exit(1);
}
kret = semaphore_create(mach_task_self(), &return_semaphore, SYNC_POLICY_FIFO, 0);
if (kret != KERN_SUCCESS) {
printf("Couldn't allocate semaphore %d\n", kret);
exit(1);
}
secargs.wakeup_semaphore = wakeup_semaphore;
secargs.return_semaphore = return_semaphore;
secargs.iterations = iterations;
secargs.pol = pol;
secargs.wakeup_second_jitter_arr = wakeup_second_jitter_arr;
secargs.woke_on_same_cpu = 0;
secargs.too_much = too_much;
secargs.last_poke_time = 0ULL;
secargs.cpuno = 0;
res = pthread_create(§hread, NULL, second_thread, &secargs);
if (res) {
err(1, "pthread_create");
}
sleep(1); /* Time for other thread to start up */
}
/* Set scheduling policy */
res = thread_setup(pol);
if (res != 0) {
printf("Couldn't set thread policy.\n");
exit(1);
}
/*
* Repeatedly pick a random timer length and
* try to sleep exactly that long
*/
for (i = 0; i < iterations; i++) {
sleep_length_abs = (uint64_t) (get_random_sleep_length_abs_ns(min_sleep_ns, max_sleep_ns) * (((double)g_mti.denom) / ((double)g_mti.numer)));
target_time = mach_absolute_time() + sleep_length_abs;
/* Sleep */
kret = mach_wait_until(target_time);
wake_time = mach_absolute_time();
jitter_arr[i] = (double)(wake_time - target_time);
fraction_arr[i] = jitter_arr[i] / ((double)sleep_length_abs);
/* Too much: cut a tracepoint for a debugger */
if (jitter_arr[i] >= too_much) {
kdebug_trace(0xeeeee0 | DBG_FUNC_NONE, 0, 0, 0, 0);
}
if (wakeup_second_thread) {
secargs.last_poke_time = mach_absolute_time();
secargs.cpuno = cpu_number();
OSMemoryBarrier();
kret = semaphore_signal(wakeup_semaphore);
if (kret != KERN_SUCCESS) {
errx(1, "semaphore_signal");
}
kret = semaphore_wait(return_semaphore);
if (kret != KERN_SUCCESS) {
errx(1, "semaphore_wait");
}
}
}
/*
* Compute statistics and output results.
*/
compute_stats(jitter_arr, iterations, &avg, &max, &min, &stddev);
compute_stats(fraction_arr, iterations, &avg_fract, &max_fract, &min_fract, &stddev_fract);
putchar('\n');
print_stats_us("jitter", avg, max, min, stddev);
print_stats_fract("%", avg_fract, max_fract, min_fract, stddev_fract);
if (wakeup_second_thread) {
res = pthread_join(secthread, NULL);
if (res) {
err(1, "pthread_join");
}
compute_stats(wakeup_second_jitter_arr, iterations, &avg, &max, &min, &stddev);
putchar('\n');
print_stats_us("second jitter", avg, max, min, stddev);
putchar('\n');
printf("%llu/%llu (%.1f%%) wakeups on same CPU\n", secargs.woke_on_same_cpu, iterations,
100.0*((double)secargs.woke_on_same_cpu)/iterations);
}
return 0;
}
void *
server(void *serverarg)
{
int idx;
kern_return_t ret;
int totalmsg = num_msgs * num_clients;
mach_port_t recv_port;
uint64_t starttm, endtm;
int svr_num = (int)(uintptr_t)serverarg;
struct port_args *args = &server_port_args[svr_num];
args->server_num = svr_num;
setup_server_ports(args);
thread_setup(args->server_num + 1);
recv_port = (useset) ? args->rcv_set : args->port;
for (idx = 0; idx < totalmsg; idx++) {
if (verbose > 2)
printf("server awaiting message %d\n", idx);
ret = mach_msg(args->req_msg,
MACH_RCV_MSG|MACH_RCV_INTERRUPT|MACH_RCV_LARGE,
0,
args->req_size,
recv_port,
MACH_MSG_TIMEOUT_NONE,
MACH_PORT_NULL);
if (MACH_RCV_INTERRUPTED == ret)
break;
if (MACH_MSG_SUCCESS != ret) {
if (verbose)
printf("mach_msg() ret=%d", ret);
mach_error("mach_msg (receive): ", ret);
exit(1);
}
if (verbose > 2)
printf("server received message %d\n", idx);
if (args->req_msg->msgh_bits & MACH_MSGH_BITS_COMPLEX) {
ret = vm_deallocate(mach_task_self(),
(vm_address_t)((ipc_complex_message *)args->req_msg)->descriptor.address,
((ipc_complex_message *)args->req_msg)->descriptor.size);
}
if (1 == args->req_msg->msgh_id) {
if (verbose > 2)
printf("server sending reply %d\n", idx);
args->reply_msg->msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_MOVE_SEND_ONCE, 0);
args->reply_msg->msgh_size = args->reply_size;
args->reply_msg->msgh_remote_port = args->req_msg->msgh_remote_port;
args->reply_msg->msgh_local_port = MACH_PORT_NULL;
args->reply_msg->msgh_id = 2;
ret = mach_msg(args->reply_msg,
MACH_SEND_MSG,
args->reply_size,
0,
MACH_PORT_NULL,
MACH_MSG_TIMEOUT_NONE,
MACH_PORT_NULL);
if (MACH_MSG_SUCCESS != ret) {
mach_error("mach_msg (send): ", ret);
exit(1);
}
}
}
if (!useset)
return NULL;
if (verbose < 1)
return NULL;
uint64_t deltans = 0;
/*
* If we're using multiple sets, explicitly tear them all down
* and measure the time.
*/
for (int ns = 0; ns < setcount; ns++) {
if (verbose > 1)
printf("\tTearing down set[%d] %#x...\n", ns, args->set[ns]);
starttm = mach_absolute_time();
ret = mach_port_mod_refs(mach_task_self(), args->set[ns], MACH_PORT_RIGHT_PORT_SET, -1);
endtm = mach_absolute_time();
deltans += abs_to_ns(endtm - starttm);
if (ret != KERN_SUCCESS) {
mach_error("mach_port_mod_refs(): ", ret);
exit(1);
}
}
uint64_t nlinks = (uint64_t)setcount * (uint64_t)portcount;
printf("\tteardown of %llu links took %llu ns\n", nlinks, deltans);
printf("\t%lluns per set\n", deltans / (uint64_t)setcount);
return NULL;
}
int main(int argc, char *argv[])
{
int i;
int j;
thread_id_t *client_id;
thread_id_t *server_id;
signal(SIGINT, signal_handler);
parse_args(argc, argv);
calibrate_client_work();
/*
* If we're using affinity create an empty namespace now
* so this is shared by all our offspring.
*/
if (affinity)
thread_setup(0);
server_id = (thread_id_t *) malloc(num_servers * sizeof(thread_id_t));
server_port_name = (char **) malloc(num_servers * sizeof(char *));
if (verbose)
printf("creating %d servers\n", num_servers);
for (i = 0; i < num_servers; i++) {
server_port_name[i] = (char *) malloc(sizeof("PORT.pppppp.xx"));
/* PORT names include pid of main process for disambiguation */
sprintf(server_port_name[i], "PORT.%06d.%02d", getpid(), i);
thread_spawn(&server_id[i], server, (void *) (long) i);
}
int totalclients = num_servers * num_clients;
int totalmsg = num_msgs * totalclients;
struct timeval starttv, endtv, deltatv;
/*
* Wait for all servers to have registered all ports before starting
* the clients and the clock.
*/
wait_for_servers();
printf("%d server%s, %d client%s per server (%d total) %u messages...",
num_servers, (num_servers > 1)? "s" : "",
num_clients, (num_clients > 1)? "s" : "",
totalclients,
totalmsg);
fflush(stdout);
/* Call gettimeofday() once and throw away result; some implementations
* (like Mach's) cache some time zone info on first call.
*/
gettimeofday(&starttv, NULL);
gettimeofday(&starttv, NULL);
client_id = (thread_id_t *) malloc(totalclients * sizeof(thread_id_t));
if (verbose)
printf("creating %d clients\n", totalclients);
for (i = 0; i < num_servers; i++) {
for (j = 0; j < num_clients; j++) {
thread_spawn(
&client_id[(i*num_clients) + j],
client,
(void *) (long) i);
}
}
/* Wait for servers to complete */
for (i = 0; i < num_servers; i++) {
thread_join(&server_id[i]);
}
gettimeofday(&endtv, NULL);
for (i = 0; i < totalclients; i++) {
thread_join(&client_id[i]);
}
/* report results */
deltatv.tv_sec = endtv.tv_sec - starttv.tv_sec;
deltatv.tv_usec = endtv.tv_usec - starttv.tv_usec;
if (endtv.tv_usec < starttv.tv_usec) {
deltatv.tv_sec--;
deltatv.tv_usec += 1000000;
}
double dsecs = (double) deltatv.tv_sec +
1.0E-6 * (double) deltatv.tv_usec;
printf(" in %u.%03u seconds\n",
deltatv.tv_sec, deltatv.tv_usec/1000);
printf(" throughput in messages/sec: %g\n",
(double)totalmsg / dsecs);
printf(" average message latency (usec): %2.3g\n",
dsecs * 1.0E6 / (double) totalmsg);
return (0);
}
void *
server(void *serverarg)
{
int kq;
struct kevent64_s kev[1];
int err;
struct port_args args;
int idx;
kern_return_t ret;
int totalmsg = num_msgs * num_clients;
args.server_num = (int) (long) serverarg;
setup_server_ports(&args);
thread_setup(args.server_num + 1);
kq = kqueue();
if (kq == -1) {
perror("kqueue");
exit(1);
}
EV_SET64(&kev[0], args.pset, EVFILT_MACHPORT, (EV_ADD | EV_CLEAR | EV_DISPATCH),
#if DIRECT_MSG_RCV
MACH_RCV_MSG|MACH_RCV_LARGE, 0, 0, (mach_vm_address_t)args.req_msg, args.req_size);
#else
0, 0, 0, 0, 0);
#endif
err = kevent64(kq, kev, 1, NULL, 0, 0, NULL);
if (err == -1) {
perror("kevent");
exit(1);
}
for (idx = 0; idx < totalmsg; idx++) {
if (verbose)
printf("server awaiting message %d\n", idx);
retry:
EV_SET64(&kev[0], args.pset, EVFILT_MACHPORT, EV_ENABLE,
#if DIRECT_MSG_RCV
MACH_RCV_MSG|MACH_RCV_LARGE, 0, 0, (mach_vm_address_t)args.req_msg, args.req_size);
#else
0, 0, 0, 0, 0);
#endif
err = kevent64(kq, kev, 1, kev, 1, 0, NULL);
if (err == -1) {
perror("kevent64");
exit(1);
}
if (err == 0) {
// printf("kevent64: returned zero\n");
goto retry;
}
#if DIRECT_MSG_RCV
ret = kev[0].fflags;
if (MACH_MSG_SUCCESS != ret) {
if (verbose)
printf("kevent64() mach_msg_return=%d", ret);
mach_error("kevent64 (msg receive): ", ret);
exit(1);
}
#else
if (kev[0].data != args.port)
printf("kevent64(MACH_PORT_NULL) port name (0x%x) != expected (0x%x)\n", kev[0].data, args.port);
args.req_msg->msgh_bits = 0;
args.req_msg->msgh_size = args.req_size;
args.req_msg->msgh_local_port = args.port;
ret = mach_msg(args.req_msg,
MACH_RCV_MSG|MACH_RCV_INTERRUPT|MACH_RCV_LARGE,
0,
args.req_size,
args.pset,
MACH_MSG_TIMEOUT_NONE,
MACH_PORT_NULL);
if (MACH_RCV_INTERRUPTED == ret)
break;
if (MACH_MSG_SUCCESS != ret) {
if (verbose)
printf("mach_msg() ret=%d", ret);
mach_error("mach_msg (receive): ", ret);
exit(1);
}
#endif
if (verbose)
printf("server received message %d\n", idx);
if (args.req_msg->msgh_bits & MACH_MSGH_BITS_COMPLEX) {
ret = vm_deallocate(mach_task_self(),
(vm_address_t)((ipc_complex_message *)args.req_msg)->descriptor.address,
((ipc_complex_message *)args.req_msg)->descriptor.size);
}
if (1 == args.req_msg->msgh_id) {
if (verbose)
printf("server sending reply %d\n", idx);
args.reply_msg->msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND,
MACH_MSG_TYPE_MAKE_SEND);
args.reply_msg->msgh_size = args.reply_size;
args.reply_msg->msgh_remote_port = args.req_msg->msgh_remote_port;
args.reply_msg->msgh_local_port = args.req_msg->msgh_local_port;
args.reply_msg->msgh_id = 2;
ret = mach_msg(args.reply_msg,
MACH_SEND_MSG,
args.reply_size,
0,
MACH_PORT_NULL,
MACH_MSG_TIMEOUT_NONE,
MACH_PORT_NULL);
if (MACH_MSG_SUCCESS != ret) {
mach_error("mach_msg (send): ", ret);
exit(1);
}
}
}
}
bool HitTestEngine::start()
{
// don't know if we even need this any more
#ifdef _MSC_VER
thread_setup();
#endif
// if it's a single request type, we need to create a temp Script object
// to pass to the threads, then delete it later on
if (m_hitTestType == HIT_REQUEST)
{
if (!m_pRequest) // shouldn't happen, but...
{
return false;
}
m_pScript = new Script(m_pRequest);
}
// copy script over, so load test results saver knows about each step
if (m_pSaver && m_pScript)
{
m_pSaver->copyScript(*m_pScript);
}
std::vector<HitLoadRequestThread *> aThreads;
int threadCount = 0;
for (int i = 0; i < m_numberOfThreads; i++)
{
RequestThreadData *data = new RequestThreadData(i + 1, m_pScript, m_pSaver, m_repeats);
HitLoadRequestThread *newThread = new HitLoadRequestThread(data);
if (newThread)
{
threadCount++;
aThreads.push_back(newThread);
}
}
printf("Created %i threads...\n", threadCount);
std::vector<HitLoadRequestThread *>::iterator it = aThreads.begin();
for (; it != aThreads.end(); ++it)
{
(*it)->start();
}
for (it = aThreads.begin(); it != aThreads.end(); ++it)
{
(*it)->waitForCompletion();
delete *it;
}
if (m_hitTestType == HIT_REQUEST && m_pScript)
{
delete m_pScript;
}
printf("All threads finished.\n");
#ifdef _MSC_VER
thread_cleanup();
#endif
return true;
}
/* PrepareToBoot */
static void
handle_csm_0002(struct bregs *regs)
{
if (!CONFIG_BOOT) {
regs->ax = 1;
return;
}
dprintf(3, "PrepareToBoot table %04x:%04x\n", regs->es, regs->bx);
struct e820entry *p = (void *)csm_compat_table.E820Pointer;
int i;
for (i=0; i < csm_compat_table.E820Length / sizeof(struct e820entry); i++)
e820_add(p[i].start, p[i].size, p[i].type);
if (csm_init_table->HiPmmMemorySizeInBytes > BUILD_MAX_HIGHTABLE) {
u32 hi_pmm_end = csm_init_table->HiPmmMemory + csm_init_table->HiPmmMemorySizeInBytes;
e820_add(hi_pmm_end - BUILD_MAX_HIGHTABLE, BUILD_MAX_HIGHTABLE, E820_RESERVED);
}
// For PCIBIOS 1ab10e
if (csm_compat_table.IrqRoutingTablePointer &&
csm_compat_table.IrqRoutingTableLength) {
PirAddr = (void *)csm_compat_table.IrqRoutingTablePointer;
dprintf(3, "CSM PIRQ table at %p\n", PirAddr);
}
// For find_resume_vector()... and find_acpi_features()
if (csm_rsdp.signature == RSDP_SIGNATURE) {
RsdpAddr = &csm_rsdp;
dprintf(3, "CSM ACPI RSDP at %p\n", RsdpAddr);
find_acpi_features();
}
// SMBIOS table needs to be copied into the f-seg
// XX: OVMF doesn't seem to set SmbiosTableLength so don't check it
if (csm_boot_table->SmbiosTable && !SMBiosAddr)
copy_smbios((void *)csm_boot_table->SmbiosTable);
// MPTABLE is just there; we don't care where.
// EFI may have reinitialised the video using its *own* driver.
enable_vga_console();
// EFI fills this in for us. Zero it for now...
struct bios_data_area_s *bda = MAKE_FLATPTR(SEG_BDA, 0);
bda->hdcount = 0;
thread_setup();
mathcp_setup();
timer_setup();
clock_setup();
device_hardware_setup();
wait_threads();
interactive_bootmenu();
prepareboot();
regs->ax = 0;
}
/*
* Import data into GPDB.
* invoked by GPDB, be careful with C++ exceptions.
*/
Datum s3_import(PG_FUNCTION_ARGS) {
S3ExtBase *myData;
char *data;
int data_len;
size_t nread = 0;
/* Must be called via the external table format manager */
if (!CALLED_AS_EXTPROTOCOL(fcinfo))
elog(ERROR,
"extprotocol_import: not called by external protocol manager");
/* Get our internal description of the protocol */
myData = (S3ExtBase *)EXTPROTOCOL_GET_USER_CTX(fcinfo);
if (EXTPROTOCOL_IS_LAST_CALL(fcinfo)) {
if (myData) {
thread_cleanup();
if (!myData->Destroy()) {
ereport(ERROR, (0, errmsg("Failed to cleanup S3 extention")));
}
delete myData;
}
/*
* Cleanup function for the XML library.
*/
xmlCleanupParser();
PG_RETURN_INT32(0);
}
if (myData == NULL) {
/* first call. do any desired init */
curl_global_init(CURL_GLOBAL_ALL);
thread_setup();
const char *p_name = "s3";
char *url_with_options = EXTPROTOCOL_GET_URL(fcinfo);
char *url = truncate_options(url_with_options);
char *config_path = get_opt_s3(url_with_options, "config");
if (!config_path) {
// no config path in url, use default value
// data_folder/gpseg0/s3/s3.conf
config_path = strdup("s3/s3.conf");
}
bool result = InitConfig(config_path, "");
if (!result) {
free(config_path);
ereport(ERROR, (0, errmsg("Can't find config file, please check")));
} else {
ClearConfig();
free(config_path);
}
InitLog();
if (s3ext_accessid == "") {
ereport(ERROR, (0, errmsg("ERROR: access id is empty")));
}
if (s3ext_secret == "") {
ereport(ERROR, (0, errmsg("ERROR: secret is empty")));
}
if ((s3ext_segnum == -1) || (s3ext_segid == -1)) {
ereport(ERROR, (0, errmsg("ERROR: segment id is invalid")));
}
myData = CreateExtWrapper(url);
if (!myData ||
!myData->Init(s3ext_segid, s3ext_segnum, s3ext_chunksize)) {
if (myData) delete myData;
ereport(ERROR, (0, errmsg("Failed to init S3 extension, segid = "
"%d, segnum = %d, please check your "
"configurations and net connection",
s3ext_segid, s3ext_segnum)));
}
EXTPROTOCOL_SET_USER_CTX(fcinfo, myData);
free(url);
}
/* =======================================================================
* DO THE IMPORT
* =======================================================================
*/
data = EXTPROTOCOL_GET_DATABUF(fcinfo);
data_len = EXTPROTOCOL_GET_DATALEN(fcinfo);
uint64_t readlen = 0;
if (data_len > 0) {
readlen = data_len;
if (!myData->TransferData(data, readlen))
ereport(ERROR, (0, errmsg("s3_import: could not read data")));
nread = (size_t)readlen;
// S3DEBUG("read %d data from S3", nread);
}
PG_RETURN_INT32((int)nread);
}
rstatus_t
thread_init(struct event_base *main_base)
{
rstatus_t status;
err_t err;
int nworkers = settings.num_workers;
struct thread_worker *dispatcher;
int i;
init_count = 0;
pthread_mutex_init(&init_lock, NULL);
pthread_cond_init(&init_cond, NULL);
last_thread = -1;
/* dispatcher takes the extra (last) slice of thread descriptor */
threads = mc_zalloc(sizeof(*threads) * (1 + nworkers));
if (threads == NULL) {
return MC_ENOMEM;
}
/* keep data of dispatcher close to worker threads for easy aggregation */
dispatcher = &threads[nworkers];
/* create keys for common members of thread_worker. */
err = pthread_key_create(&keys.stats_mutex, NULL);
if (err != 0) {
log_error("pthread key create failed: %s", strerror(err));
return MC_ERROR;
}
err = pthread_key_create(&keys.stats_thread, NULL);
if (err != 0) {
log_error("pthread key create failed: %s", strerror(err));
return MC_ERROR;
}
err = pthread_key_create(&keys.stats_slabs, NULL);
if (err != 0) {
log_error("pthread key create failed: %s", strerror(err));
return MC_ERROR;
}
err = pthread_key_create(&keys.kbuf, NULL);
if (err != 0) {
log_error("pthread key create failed: %s", strerror(err));
return MC_ERROR;
}
dispatcher->base = main_base;
dispatcher->tid = pthread_self();
status = thread_setup_stats(dispatcher);
if (status != MC_OK) {
return status;
}
status = thread_setkeys(dispatcher);
if (status != MC_OK) {
return status;
}
for (i = 0; i < nworkers; i++) {
int fds[2];
status = pipe(fds);
if (status < 0) {
log_error("pipe failed: %s", strerror(errno));
return status;
}
threads[i].notify_receive_fd = fds[0];
threads[i].notify_send_fd = fds[1];
status = thread_setup(&threads[i]);
if (status != MC_OK) {
return status;
}
}
/* create worker threads after we've done all the libevent setup */
for (i = 0; i < nworkers; i++) {
status = thread_create(thread_worker_main, &threads[i]);
if (status != MC_OK) {
return status;
}
}
/* wait for all the workers to set themselves up */
pthread_mutex_lock(&init_lock);
while (init_count < nworkers) {
pthread_cond_wait(&init_cond, &init_lock);
}
pthread_mutex_unlock(&init_lock);
/* for stats module */
/* setup thread data structures */
status = thread_setup_aggregator();
if (status != MC_OK) {
return status;
}
/* create thread */
status = thread_create(thread_aggregator_main, NULL);
if (status != MC_OK) {
return status;
}
/* for klogger */
/* Setup thread data structure */
status = thread_setup_klogger();
if (status != MC_OK) {
return status;
}
/* create thread */
status = thread_create(thread_klogger_main, NULL);
if (status != MC_OK) {
return status;
}
/* wait for all the workers and dispatcher to set themselves up */
pthread_mutex_lock(&init_lock);
while (init_count < nworkers + 2) { /* +2: aggregator & klogger */
pthread_cond_wait(&init_cond, &init_lock);
}
pthread_mutex_unlock(&init_lock);
return MC_OK;
}
int main(int argc, char *argv[])
{
int i;
int j;
thread_id_t *client_id;
thread_id_t *server_id;
signal(SIGINT, signal_handler);
parse_args(argc, argv);
if (mach_timebase_info(&g_timebase) != KERN_SUCCESS) {
fprintf(stderr, "Can't get mach_timebase_info!\n");
exit(1);
}
calibrate_client_work();
/*
* If we're using affinity create an empty namespace now
* so this is shared by all our offspring.
*/
if (affinity)
thread_setup(0);
server_id = (thread_id_t *) malloc(num_servers * sizeof(thread_id_t));
server_port_name = (char **) malloc(num_servers * sizeof(char *));
server_port_args = (struct port_args *)calloc(sizeof(struct port_args), num_servers);
if (!server_id || !server_port_name || !server_port_args) {
fprintf(stderr, "malloc/calloc of %d server book keeping structs failed\n", num_servers);
exit(1);
}
if (verbose)
printf("creating %d servers\n", num_servers);
for (i = 0; i < num_servers; i++) {
server_port_name[i] = (char *) malloc(sizeof("PORT.pppppp.xx"));
/* PORT names include pid of main process for disambiguation */
sprintf(server_port_name[i], "PORT.%06d.%02d", getpid(), i);
thread_spawn(&server_id[i], server, (void *) (long) i);
}
int totalclients = num_servers * num_clients;
int totalmsg = num_msgs * totalclients;
struct timeval starttv, endtv, deltatv;
/*
* Wait for all servers to have registered all ports before starting
* the clients and the clock.
*/
wait_for_servers();
printf("%d server%s, %d client%s per server (%d total) %u messages...",
num_servers, (num_servers > 1)? "s" : "",
num_clients, (num_clients > 1)? "s" : "",
totalclients,
totalmsg);
fflush(stdout);
/* Call gettimeofday() once and throw away result; some implementations
* (like Mach's) cache some time zone info on first call.
*/
gettimeofday(&starttv, NULL);
gettimeofday(&starttv, NULL);
client_id = (thread_id_t *) malloc(totalclients * sizeof(thread_id_t));
if (verbose)
printf("creating %d clients\n", totalclients);
for (i = 0; i < num_servers; i++) {
for (j = 0; j < num_clients; j++) {
thread_spawn(
&client_id[(i*num_clients) + j],
client,
(void *) (long) i);
}
}
/* Wait for servers to complete */
for (i = 0; i < num_servers; i++) {
thread_join(&server_id[i]);
}
gettimeofday(&endtv, NULL);
if (verbose)
printf("all servers complete: waiting for clients...\n");
for (i = 0; i < totalclients; i++) {
thread_join(&client_id[i]);
}
/* report results */
deltatv.tv_sec = endtv.tv_sec - starttv.tv_sec;
deltatv.tv_usec = endtv.tv_usec - starttv.tv_usec;
if (endtv.tv_usec < starttv.tv_usec) {
deltatv.tv_sec--;
deltatv.tv_usec += 1000000;
}
double dsecs = (double) deltatv.tv_sec +
1.0E-6 * (double) deltatv.tv_usec;
printf(" in %lu.%03u seconds\n",
deltatv.tv_sec, deltatv.tv_usec/1000);
printf(" throughput in messages/sec: %g\n",
(double)totalmsg / dsecs);
printf(" average message latency (usec): %2.3g\n",
dsecs * 1.0E6 / (double) totalmsg);
double time_in_sec = (double)deltatv.tv_sec + (double)deltatv.tv_usec/1000.0;
double throughput_msg_p_sec = (double) totalmsg/dsecs;
double avg_msg_latency = dsecs*1.0E6 / (double)totalmsg;
if (save_perfdata == TRUE) {
record_perf_data("mpmm_avg_msg_latency", "usec", avg_msg_latency, "Message latency measured in microseconds. Lower is better", stderr);
}
if (stress_prepost) {
int64_t sendns = abs_to_ns(g_client_send_time);
dsecs = (double)sendns / (double)NSEC_PER_SEC;
printf(" total send time: %2.3gs\n", dsecs);
printf(" average send time (usec): %2.3g\n",
dsecs * 1.0E6 / (double)totalmsg);
}
return (0);
}
int main(int argc, char *argv[])
{
char *CApath = NULL, *CAfile = NULL;
int badop = 0;
int ret = 1;
int client_auth = 0;
int server_auth = 0;
SSL_CTX *s_ctx = NULL;
SSL_CTX *c_ctx = NULL;
char *scert = TEST_SERVER_CERT;
char *ccert = TEST_CLIENT_CERT;
SSL_METHOD *ssl_method = SSLv23_method();
RAND_seed(rnd_seed, sizeof rnd_seed);
if (bio_err == NULL)
bio_err = BIO_new_fp(stderr, BIO_NOCLOSE);
if (bio_stdout == NULL)
bio_stdout = BIO_new_fp(stdout, BIO_NOCLOSE);
argc--;
argv++;
while (argc >= 1) {
if (sgx_strcmp(*argv, "-server_auth") == 0)
server_auth = 1;
else if (sgx_strcmp(*argv, "-client_auth") == 0)
client_auth = 1;
else if (sgx_strcmp(*argv, "-reconnect") == 0)
reconnect = 1;
else if (sgx_strcmp(*argv, "-stats") == 0)
cache_stats = 1;
else if (sgx_strcmp(*argv, "-ssl3") == 0)
ssl_method = SSLv3_method();
else if (sgx_strcmp(*argv, "-ssl2") == 0)
ssl_method = SSLv2_method();
else if (sgx_strcmp(*argv, "-CApath") == 0) {
if (--argc < 1)
goto bad;
CApath = *(++argv);
} else if (sgx_strcmp(*argv, "-CAfile") == 0) {
if (--argc < 1)
goto bad;
CAfile = *(++argv);
} else if (sgx_strcmp(*argv, "-cert") == 0) {
if (--argc < 1)
goto bad;
scert = *(++argv);
} else if (sgx_strcmp(*argv, "-ccert") == 0) {
if (--argc < 1)
goto bad;
ccert = *(++argv);
} else if (sgx_strcmp(*argv, "-threads") == 0) {
if (--argc < 1)
goto bad;
thread_number = atoi(*(++argv));
if (thread_number == 0)
thread_number = 1;
if (thread_number > MAX_THREAD_NUMBER)
thread_number = MAX_THREAD_NUMBER;
} else if (sgx_strcmp(*argv, "-loops") == 0) {
if (--argc < 1)
goto bad;
number_of_loops = atoi(*(++argv));
if (number_of_loops == 0)
number_of_loops = 1;
} else {
fprintf(stderr, "unknown option %s\n", *argv);
badop = 1;
break;
}
argc--;
argv++;
}
if (badop) {
bad:
sv_usage();
goto end;
}
if (cipher == NULL && OPENSSL_issetugid() == 0)
cipher = getenv("SSL_CIPHER");
SSL_load_error_strings();
OpenSSL_add_ssl_algorithms();
c_ctx = SSL_CTX_new(ssl_method);
s_ctx = SSL_CTX_new(ssl_method);
if ((c_ctx == NULL) || (s_ctx == NULL)) {
ERR_print_errors(bio_err);
goto end;
}
SSL_CTX_set_session_cache_mode(s_ctx,
SSL_SESS_CACHE_NO_AUTO_CLEAR |
SSL_SESS_CACHE_SERVER);
SSL_CTX_set_session_cache_mode(c_ctx,
SSL_SESS_CACHE_NO_AUTO_CLEAR |
SSL_SESS_CACHE_SERVER);
if (!SSL_CTX_use_certificate_file(s_ctx, scert, SSL_FILETYPE_PEM)) {
ERR_print_errors(bio_err);
} else
if (!SSL_CTX_use_RSAPrivateKey_file(s_ctx, scert, SSL_FILETYPE_PEM)) {
ERR_print_errors(bio_err);
goto end;
}
if (client_auth) {
SSL_CTX_use_certificate_file(c_ctx, ccert, SSL_FILETYPE_PEM);
SSL_CTX_use_RSAPrivateKey_file(c_ctx, ccert, SSL_FILETYPE_PEM);
}
if ((!SSL_CTX_load_verify_locations(s_ctx, CAfile, CApath)) ||
(!SSL_CTX_set_default_verify_paths(s_ctx)) ||
(!SSL_CTX_load_verify_locations(c_ctx, CAfile, CApath)) ||
(!SSL_CTX_set_default_verify_paths(c_ctx))) {
fprintf(stderr, "SSL_load_verify_locations\n");
ERR_print_errors(bio_err);
goto end;
}
if (client_auth) {
fprintf(stderr, "client authentication\n");
SSL_CTX_set_verify(s_ctx,
SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
verify_callback);
}
if (server_auth) {
fprintf(stderr, "server authentication\n");
SSL_CTX_set_verify(c_ctx, SSL_VERIFY_PEER, verify_callback);
}
thread_setup();
do_threads(s_ctx, c_ctx);
thread_cleanup();
end:
if (c_ctx != NULL) {
fprintf(stderr, "Client SSL_CTX stats then free it\n");
print_stats(stderr, c_ctx);
SSL_CTX_free(c_ctx);
}
if (s_ctx != NULL) {
fprintf(stderr, "Server SSL_CTX stats then free it\n");
print_stats(stderr, s_ctx);
if (cache_stats) {
fprintf(stderr, "-----\n");
lh_stats(SSL_CTX_sessions(s_ctx), stderr);
fprintf(stderr, "-----\n");
/*- lh_node_stats(SSL_CTX_sessions(s_ctx),stderr);
fprintf(stderr,"-----\n"); */
lh_node_usage_stats(SSL_CTX_sessions(s_ctx), stderr);
fprintf(stderr, "-----\n");
}
SSL_CTX_free(s_ctx);
fprintf(stderr, "done free\n");
}
exit(ret);
return (0);
}
void *client(void *threadarg)
{
struct port_args args;
struct port_args *svr_args = NULL;
int idx;
mach_msg_header_t *req, *reply;
mach_port_t bsport, servport;
kern_return_t ret;
int server_num = (int)(uintptr_t)threadarg;
void *ints = malloc(sizeof(u_int32_t) * num_ints);
if (verbose)
printf("client(%d) started, server port name %s\n",
server_num, server_port_name[server_num]);
args.server_num = server_num;
thread_setup(server_num + 1);
if (stress_prepost)
svr_args = &server_port_args[server_num];
/* find server port */
ret = task_get_bootstrap_port(mach_task_self(), &bsport);
if (KERN_SUCCESS != ret) {
mach_error("task_get_bootstrap_port(): ", ret);
exit(1);
}
ret = bootstrap_look_up(bsport,
server_port_name[server_num],
&servport);
if (KERN_SUCCESS != ret) {
mach_error("bootstrap_look_up(): ", ret);
exit(1);
}
setup_client_ports(&args);
/* Allocate and touch memory */
if (client_pages) {
unsigned i;
client_memory = (long *) malloc(client_pages * PAGE_SIZE);
for (i = 0; i < client_pages; i++)
client_memory[i * PAGE_SIZE / sizeof(long)] = 0;
}
uint64_t starttm, endtm;
/* start message loop */
for (idx = 0; idx < num_msgs; idx++) {
req = args.req_msg;
reply = args.reply_msg;
req->msgh_size = args.req_size;
if (stress_prepost) {
req->msgh_remote_port = svr_args->port_list[idx % portcount];
} else {
req->msgh_remote_port = servport;
}
if (oneway) {
req->msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0);
req->msgh_local_port = MACH_PORT_NULL;
} else {
req->msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND,
MACH_MSG_TYPE_MAKE_SEND_ONCE);
req->msgh_local_port = args.port;
}
req->msgh_id = oneway ? 0 : 1;
if (msg_type == msg_type_complex) {
(req)->msgh_bits |= MACH_MSGH_BITS_COMPLEX;
((ipc_complex_message *)req)->body.msgh_descriptor_count = 1;
((ipc_complex_message *)req)->descriptor.address = ints;
((ipc_complex_message *)req)->descriptor.size =
num_ints * sizeof(u_int32_t);
((ipc_complex_message *)req)->descriptor.deallocate = FALSE;
((ipc_complex_message *)req)->descriptor.copy = MACH_MSG_VIRTUAL_COPY;
((ipc_complex_message *)req)->descriptor.type = MACH_MSG_OOL_DESCRIPTOR;
}
if (verbose > 2)
printf("client sending message %d to port %#x\n",
idx, req->msgh_remote_port);
starttm = mach_absolute_time();
ret = mach_msg(req,
MACH_SEND_MSG,
args.req_size,
0,
MACH_PORT_NULL,
MACH_MSG_TIMEOUT_NONE,
MACH_PORT_NULL);
endtm = mach_absolute_time();
if (MACH_MSG_SUCCESS != ret) {
mach_error("mach_msg (send): ", ret);
fprintf(stderr, "bailing after %u iterations\n", idx);
exit(1);
break;
}
if (stress_prepost)
OSAtomicAdd64(endtm - starttm, &g_client_send_time);
if (!oneway) {
if (verbose > 2)
printf("client awaiting reply %d\n", idx);
reply->msgh_bits = 0;
reply->msgh_size = args.reply_size;
reply->msgh_local_port = args.port;
ret = mach_msg(args.reply_msg,
MACH_RCV_MSG|MACH_RCV_INTERRUPT,
0,
args.reply_size,
args.port,
MACH_MSG_TIMEOUT_NONE,
MACH_PORT_NULL);
if (MACH_MSG_SUCCESS != ret) {
mach_error("mach_msg (receive): ", ret);
fprintf(stderr, "bailing after %u iterations\n",
idx);
exit(1);
}
if (verbose > 2)
printf("client received reply %d\n", idx);
}
client_work();
}
free(ints);
return NULL;
}
