int
main(int ac, char **av)
{
char *where;
size_t size = 0;
size_t max = 0;
size_t delta;
if (ac == 2) {
max = size = bytes(av[1]) * 1024 * 1024;
}
if (max < 1024 * 1024) {
max = size = 1024 * 1024 * 1024;
}
/*
* Binary search down and then binary search up
*/
for (where = 0; !test_malloc(size); size >>= 1) {
max = size;
}
/* delta = size / (2 * 1024 * 1024) */
for (delta = (size >> 21); delta > 0; delta >>= 1) {
uint64 sz = (uint64)size + (uint64)delta * 1024 * 1024;
size_t check = sz;
if (max < sz) continue;
if (check < sz || !test_malloc(sz)) break;
size = sz;
}
if (where = malloc(size)) {
timeit(where, size);
free(where);
}
exit (0);
}
int main(int argc, char**argv)
{
char* buffer[ITER];
int i, j;
debug("Testing malloc\n");
test_malloc();
debug("1/2 done\n");
compute(100000);
test_malloc();
debug("2/2 done\n");
compute(100000);
debug("Testing realloc\n");
test_realloc();
debug("realloc done\n");
compute(100000);
debug("Testing calloc\n");
test_calloc();
debug("calloc done\n");
return 0;
}
void memtest() {
void *p1 = test_malloc(124);
void __attribute__ ((unused)) *p2 = test_malloc(124);
test_free(p1);
void __attribute__ ((unused)) *p3 = test_malloc(124);
}
int main(){
int ch;
print_menu();
do{
printf("Enter your choice: ");
scanf("%d",&ch);
switch(ch){
case TEST_MALLOC:
test_malloc();
break;
case TEST_CALLOC:
test_calloc();
break;
case TEST_REALLOC:
test_realloc();
break;
case TEST_FREE:
test_free();
break;
case TEST_SPACE:
test_get_free_space();
break;
case PRINT_MMAP:
test_print_mmap();
break;
case EXIT:
break;
default: printf("Invalid selection!!! Try Again\n");
}
}while(ch!=EXIT);
return 0;
}
void * test_malloc2(int num, int tst)
{
if (num <= 0) {
switch(tst) {
case 0:
return (void *) malloc(8); // just produce a leak
case 1: {
char *tst = (char *) malloc(10);
tst[11] = 'a'; //memory overwrite
return tst;
}
case 2: {
char *tst = (char *) malloc(10);
tst[-1] = 'a'; //memory underwrite
return tst;
}
default:
return 0;
}
} else {
return test_malloc( num - 1, tst );
}
}
void* run()
{
struct timeval begin;
gettimeofday(&begin, NULL);
if (use_pool_)
{
if (replace_)
test_pool2();
else
test_pool();
}
else
test_malloc();
struct timeval end;
gettimeofday(&end, NULL);
double spent = util::stamp_sub(&end, &begin);
long long total = max_loop_ * max_count_;
printf("loop: %lld, spent: %.4f, speed: %.4f\r\n",
total, spent, total * 1000 / (spent > 0 ? spent : 1));
return NULL;
}
void bulk_test_nb(int iters) {GASNET_BEGIN_FUNCTION();
int i;
int64_t begin, end;
stat_struct_t stput;
gasnet_handle_t *handles;
int payload;
handles = (gasnet_handle_t *) test_malloc(sizeof(gasnet_handle_t) * iters);
for (payload = min_payload; payload <= max_payload && payload > 0; payload *= 2) {
init_stat(&stput, payload);
BARRIER();
if (iamsender) {
/* measure the throughput of sending a message */
begin = TIME();
for (i = 0; i < iters; i++) {
handles[i] = gasnet_memset_nb(peerproc, tgtmem, 0x5a, payload);
}
gasnet_wait_syncnb_all(handles, iters);
end = TIME();
update_stat(&stput, (end - begin), iters);
}
BARRIER();
if (iamsender) {
print_stat(myproc, &stput, "memset_nb throughput", PRINT_THROUGHPUT);
}
}
test_free(handles);
}
void mpi_handler(gasnet_token_t token, harg_t tid, harg_t sz) {
gasnet_node_t node;
int mpipeer;
int tag;
char *buf;
gasnet_AMGetMsgSource(token, &node);
PRINT_AM(("node=%2d> AMShort MPI Request for tid=%i, nbytes=%i\n",
(int)gasnet_mynode(), (int)tid, (int)sz));
assert(tt_thread_map[tid] == node);
assert(sz > 0);
mpipeer = gasnetnode_to_mpirank[node];
tag = tid;
buf = (char*)test_malloc(sz);
MPI_LOCK();
assert(mpi_buf[tid] == NULL);
assert(mpi_recvhandle[tid] == MPI_REQUEST_NULL);
assert(mpi_sendhandle[tid] == MPI_REQUEST_NULL);
mpi_buf[tid] = buf;
mpi_bufsz[tid] = sz;
ACTION_PRINTF("node=%2d> setting MPI_Irecv, %i bytes\n", (int)gasnet_mynode(), (int)sz);
MPI_SAFE(MPI_Irecv(mpi_buf[tid], sz, MPI_BYTE, mpipeer, tag, MPI_COMM_WORLD, &(mpi_recvhandle[tid])));
assert(mpi_recvhandle[tid] != MPI_REQUEST_NULL);
MPI_UNLOCK();
}
int main(int argc,const char** argv)
{
//
error_examples();
//
example1_main();
//
test_refvarval_1();
test_bboard_1();
test_bboard_2();
test_bboard_3();
//
//test_biotypes();
//
test_parent();
test_vector();
test_malloc();
test_pnode_1();
//
test_dao_1();
test_dao_2();
//
test_io_1();
test_io_2();
test_io_3();
//
return 0;
}
int main()
{
int i;
for(i=0;i<10;i++) {
test_malloc(10+i,0);
}
mallopt(1002,0);
test_malloc(3,1);
test_malloc(3,2);
test_malloc(2,0);
return 0;
}
gasnet_memvec_t *make_vlist(void *baseaddr, size_t stride, size_t cnt, size_t chunksz) {
gasnet_memvec_t *retval = test_malloc(cnt*sizeof(gasnet_memvec_t));
size_t i;
for (i = 0; i < cnt; i++) {
retval[i].addr = ((char*)baseaddr)+i*stride;
retval[i].len = chunksz;
}
return retval;
}
void *thread_main(void *arg) {
thread_data_t *td = (thread_data_t*) arg;
int i;
int64_t start,total;
#if GASNET_PAR
gasnet_image_t *imagearray = test_malloc(nodes * sizeof(gasnet_image_t));
for (i=0; i<nodes; ++i) { imagearray[i] = threads_per_node; }
gasnet_coll_init(imagearray, td->mythread, NULL, 0, 0);
test_free(imagearray);
#else
gasnet_coll_init(NULL, 0, NULL, 0, 0);
#endif
MYBARRIER();
if (td->mythread == 0) {
printf("Running barrier test with %i iterations...\n",iters);
fflush(stdout);
}
MYBARRIER();
start = TIME();
for (i=0; i < iters; i++) {
gasnet_coll_barrier_notify(GASNET_TEAM_ALL, i, GASNET_BARRIERFLAG_IMAGES);
GASNET_Safe(gasnet_coll_barrier_wait(GASNET_TEAM_ALL, i, GASNET_BARRIERFLAG_IMAGES));
}
total = TIME() - start;
MYBARRIER();
if (td->mythread == 0) {
printf("Total time: %8.3f sec Avg Named Barrier latency: %8.3f us\n",
((float)total)/1000000, ((float)total)/iters);
fflush(stdout);
}
MYBARRIER();
start = TIME();
for (i=0; i < iters; i++) {
gasnet_coll_barrier_notify(GASNET_TEAM_ALL, 0, GASNET_BARRIERFLAG_ANONYMOUS | GASNET_BARRIERFLAG_IMAGES);
GASNET_Safe(gasnet_coll_barrier_wait(GASNET_TEAM_ALL, 0, GASNET_BARRIERFLAG_ANONYMOUS | GASNET_BARRIERFLAG_IMAGES));
}
total = TIME() - start;
MYBARRIER();
if (td->mythread == 0) {
printf("Total time: %8.3f sec Avg Anon. Barrier latency: %8.3f us\n",
((float)total)/1000000, ((float)total)/iters);
fflush(stdout);
}
MYBARRIER();
return NULL;
}
void oneway_nb_test(int iters, int nbytes, int alignment)
{GASNET_BEGIN_FUNCTION();
int i;
int64_t begin, end;
stat_struct_t st;
gasnet_handle_t *handles;
int pad = (alignment % PAGESZ);
/* initialize statistics */
init_stat(&st, nbytes, alignment);
handles = (gasnet_handle_t*) test_malloc(sizeof(gasnet_handle_t) * iters);
memset(locbuf+pad, 1, nbytes);
BARRIER();
if (iamsender) {
/* measure the throughput of sending a message */
begin = TIME();
for (i = 0; i < iters; i++) {
handles[i] = gasnet_put_nb_bulk(peerproc, rembuf, locbuf+pad, nbytes);
}
gasnet_wait_syncnb_all(handles, iters);
end = TIME();
update_stat(&st, (end - begin), iters);
}
BARRIER();
if (iamsender) {
print_stat(myproc, &st, "put_nb_bulk throughput", PRINT_THROUGHPUT);
}
/* initialize statistics */
init_stat(&st, nbytes, alignment);
if (iamsender) {
/* measure the throughput of receiving a message */
begin = TIME();
for (i = 0; i < iters; i++) {
handles[i] = gasnet_get_nb_bulk(locbuf, peerproc, rembuf+pad, nbytes);
}
gasnet_wait_syncnb_all(handles, iters);
end = TIME();
update_stat(&st, (end - begin), iters);
}
BARRIER();
if (iamsender) {
print_stat(myproc, &st, "get_nb_bulk throughput", PRINT_THROUGHPUT);
}
test_free(handles);
}
int main(void)
{
// test_boost();
test_pool();
test_mempool();
test_malloc();
// test_threadpool();
return 0;
}
void
alloc_thread_data(int threads)
{
int nodes, tot_threads;
nodes = gasnet_nodes();
tot_threads = nodes * threads;
tt_thread_map = (gasnet_node_t *) test_malloc(sizeof(gasnet_node_t) * tot_threads);
tt_thread_data = (threaddata_t *) test_malloc(sizeof(threaddata_t) * threads);
tt_addr_map = (void **) test_malloc(sizeof(void *) * tot_threads);
/* Initialize the thread to node map array and local thread data */
{
int i, j, tid, base;
void *segbase;
threaddata_t *td;
for (i = 0; i < nodes; i++) {
segbase = TEST_SEG(i);
base = i * threads;
for (j = 0; j < threads; j++) {
tid = base + j;
tt_thread_map[tid] = i;
tt_addr_map[tid] = (void *)
((uintptr_t) segbase +
(uintptr_t) (j * TEST_SEGZ_PER_THREAD));
if (i == gasnet_mynode()) {
td = &tt_thread_data[j];
td->tid = tid;
td->ltid = j;
td->tid_peer_local = base +
((j+1) % threads);
td->tid_peer = (tid+threads) %
tot_threads;
}
}
}
}
}
void * test_malloc2(int num)
{
if (num <= 0) {
return (void *) malloc(8);
} else {
return test_malloc( num - 1 );
}
}
char *
test_strndup(const char *s,
size_t n) {
char *ns;
ns = (char *)test_malloc(n+1);
assert_non_null(ns);
memcpy(ns, s, n);
ns[n] = '\0';
return ns;
}
static gpointer test_realloc(gpointer mem, gsize n_bytes)
{
guint8 *n = NULL;
if (n_bytes) {
n = test_malloc(n_bytes);
if (mem && n) {
memcpy(n, mem, n_bytes);
}
}
test_free(mem);
return(n);
}
static void *test_malloc_2D(int count, size_t size) {
char *tmp;
void **result;
int j;
tmp = test_malloc(count * (sizeof(void*) + size));
result = (void **)tmp;
tmp += count * sizeof(void *);
for (j = 0; j < count; ++j) {
result[j] = (void *)tmp;
tmp += size;
}
return (void *)result;
}
void
monoseed_init(int num)
{
int i;
if (myproc % 2 == 0) {
_mseed = (monoseed_t *) test_malloc(sizeof(monoseed_t) * num);
srand((int)TIME());
for (i = 0; i < num; i++) {
_mseed[i].seed = (int) rand() + 1;
chksum_gen(_mseed[i].seed, &_mseed[i].chksum);
}
}
return;
}
char*
test_strdup (const char *str)
{
int len;
char *copy;
if (str == NULL)
return NULL;
len = strlen (str);
copy = test_malloc (len + 1);
if (copy == NULL)
return NULL;
memcpy (copy, str, len + 1);
return copy;
}
int
main(int argc, char **argv)
{
int iters = 0;
gasnet_handlerentry_t htable[] = {
{ 201, chksum_reqh },
{ 202, chksum_reph }
};
/* call startup */
GASNET_Safe(gasnet_init(&argc, &argv));
GASNET_Safe(gasnet_attach(htable, sizeof(htable)/sizeof(gasnet_handlerentry_t), TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET));
test_init("testcore1",0,"(iters)");
assert(CHKSUM_TOTAL <= gasnet_AMMaxMedium());
if (argc > 1) iters = atoi(argv[1]);
if (!iters) iters = 1000;
if (argc > 2) test_usage();
/* get SPMD info */
chksum_iters = iters;
myproc = gasnet_mynode();
numprocs = gasnet_nodes();
/* Only allow even number for numprocs */
if (numprocs % 2 != 0) {
MSG("WARNING: This test requires an even number of nodes. Test skipped.\n");
gasnet_exit(0); /* exit 0 to prevent false negatives in test harnesses for smp-conduit */
}
peerproc = (myproc % 2) ? myproc-1 : myproc+1;
seginfo_table = (gasnet_seginfo_t *) test_malloc(sizeof(gasnet_seginfo_t) * numprocs);
printf("%d> starting monoseed_init(%d)\n", myproc, iters);
monoseed_init(iters);
printf("%d> starting chksums_test(%d)\n", myproc, iters);
chksum_test(iters);
gasnet_exit(0);
return(0);
}
int main(void)
{
int num = 0;
char *_ptr;
_ptr = malloc(4096);
mgr = mem_init(_ptr, 1024);
mem_print(mgr);
/* test */
{
printf("test malloc:\n");
num = test_malloc(50);
printf("memory out at %d times. first size=%d end size=%d\n", num, 50, 50+num*10);
mem_print(mgr);
strcpy(ptr[1], "*****@*****.**");
strcpy(ptr[3], "tain@linuxmint: /opt/broadcom/7851/a0");
mem_print(mgr);
// mem_dump(mgr);
}
FREE(mgr, ptr[1]);
mem_print(mgr);
getchar();
FREE(mgr, ptr[3]);
mem_print(mgr);
getchar();
{
printf("test free: num=%d\n", num);
test_free(num + 2);
mem_print(mgr);
// mem_dump(mgr);
}
mem_deinit(mgr);
free(_ptr);
return 0;
}
void test_cbt_util_create_bitmap_write_failure(void **state)
{
int result;
char* args[] = { "cbt-util", "-n", "test_disk.log", "-s", "4194304" };
void *log_meta;
log_meta = test_malloc(sizeof(struct cbt_log_metadata));
FILE *test_log = fmemopen(log_meta, sizeof(struct cbt_log_metadata), "w+");
/* Make IO errors happen immediately, not on flush */
setbuf(test_log, NULL);
will_return(__wrap_fopen, test_log);
expect_value(__wrap_fclose, fp, test_log);
result = cbt_util_create(5, args);
assert_int_equal(result, -EIO);
test_free(log_meta);
}
void test_cbt_util_create_success(void **state)
{
int result;
int file_size;
char* args[] = { "cbt-util", "-n", "test_disk.log", "-s", "4194304" };
void *log_meta;
file_size = 4194304 + sizeof(struct cbt_log_metadata);
log_meta = test_malloc(file_size);
FILE *test_log = fmemopen(log_meta, file_size, "w+");
will_return(__wrap_fopen, test_log);
expect_value(__wrap_fclose, fp, test_log);
result = cbt_util_create(5, args);
assert_int_equal(result, 0);
assert_int_equal(((struct cbt_log_metadata*)log_meta)->consistent, 0);
test_free(log_meta);
}
/* called by a single thread after gasnet_attach and args parsing */
void attach_test_mpi(void) {
int rank;
int gasnet_node;
int mpinodes;
int tot_threads;
int i;
MPI_SAFE(MPI_Barrier(MPI_COMM_WORLD));
/* setup gasnetnode <=> mpi rank mappings */
gasnetnode_to_mpirank = test_malloc(sizeof(int)*gasnet_nodes());
mpirank_to_gasnetnode = test_malloc(sizeof(int)*gasnet_nodes());
MPI_SAFE(MPI_Comm_rank(MPI_COMM_WORLD, &rank));
MPI_SAFE(MPI_Comm_size(MPI_COMM_WORLD, &mpinodes));
printf("GASNet node %i == MPI node %i\n", (int)gasnet_mynode(), rank);
if (gasnet_mynode() != rank)
printf("WARNING: Node numbering between GASNet and MPI do not coincide\n");
assert_always(mpinodes == gasnet_nodes() && rank >= 0 && rank < mpinodes);
gasnet_node = gasnet_mynode();
MPI_SAFE(MPI_Allgather(&gasnet_node,sizeof(int),MPI_BYTE,
mpirank_to_gasnetnode,sizeof(int),MPI_BYTE,
MPI_COMM_WORLD));
assert_always(mpirank_to_gasnetnode[rank] == gasnet_mynode());
for (i = 0; i < mpinodes; i++) gasnetnode_to_mpirank[i] = -1;
for (i = 0; i < mpinodes; i++) gasnetnode_to_mpirank[mpirank_to_gasnetnode[i]] = i;
for (i = 0; i < mpinodes; i++) assert_always(gasnetnode_to_mpirank[i] != -1);
tot_threads = threads_num * gasnet_nodes();
mpi_recvhandle = test_malloc(sizeof(MPI_Request)*tot_threads);
mpi_sendhandle = test_malloc(sizeof(MPI_Request)*tot_threads);
mpi_buf = test_malloc(sizeof(char *)*tot_threads);
mpi_bufsz = test_malloc(sizeof(int)*tot_threads);
for (i = 0; i < tot_threads; i++) {
mpi_recvhandle[i] = MPI_REQUEST_NULL;
mpi_sendhandle[i] = MPI_REQUEST_NULL;
mpi_buf[i] = NULL;
mpi_bufsz[i] = 0;
}
MPI_SAFE(MPI_Barrier(MPI_COMM_WORLD));
}
int
main(int argc, char *argv[])
{
int clt_sk[MAX_CLIENTS], accept_sk[MAX_CLIENTS];
int listen_sk, clt2_sk, accept2_sk;
sockaddr_storage_t clt_loop[MAX_CLIENTS];
sockaddr_storage_t svr_loop, accept_loop, clt2_loop;
socklen_t addrlen;
int error, i;
char *message = "hello, world!\n";
char msgbuf[100];
int pf_class;
struct pollfd poll_fd;
fd_set set;
struct msghdr outmessage;
char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
struct iovec out_iov;
struct cmsghdr *cmsg;
struct sctp_sndrcvinfo *sinfo;
struct msghdr inmessage;
char incmsg[CMSG_SPACE(sizeof(sctp_cmsg_data_t))];
char *big_buffer;
struct iovec iov;
/* Rather than fflush() throughout the code, set stdout to
* be unbuffered.
*/
setvbuf(stdout, NULL, _IONBF, 0);
/* Initialize the server and client addresses. */
#if TEST_V6
pf_class = PF_INET6;
svr_loop.v6.sin6_family = AF_INET6;
svr_loop.v6.sin6_addr = in6addr_loopback;
svr_loop.v6.sin6_port = htons(SCTP_TESTPORT_1);
for (i = 0; i < MAX_CLIENTS; i++) {
clt_loop[i].v6.sin6_family = AF_INET6;
clt_loop[i].v6.sin6_addr = in6addr_loopback;
clt_loop[i].v6.sin6_port = htons(SCTP_TESTPORT_2 + i);
}
clt2_loop.v6.sin6_family = AF_INET6;
clt2_loop.v6.sin6_addr = in6addr_loopback;
clt2_loop.v6.sin6_port = htons(SCTP_TESTPORT_2 + i);
#else
pf_class = PF_INET;
svr_loop.v4.sin_family = AF_INET;
svr_loop.v4.sin_addr.s_addr = SCTP_IP_LOOPBACK;
svr_loop.v4.sin_port = htons(SCTP_TESTPORT_1);
for (i = 0; i < MAX_CLIENTS; i++) {
clt_loop[i].v4.sin_family = AF_INET;
clt_loop[i].v4.sin_addr.s_addr = SCTP_IP_LOOPBACK;
clt_loop[i].v4.sin_port = htons(SCTP_TESTPORT_2 + i);
}
clt2_loop.v4.sin_family = AF_INET;
clt2_loop.v4.sin_addr.s_addr = SCTP_IP_LOOPBACK;
clt2_loop.v4.sin_port = htons(SCTP_TESTPORT_2 + i);
#endif
/* Create and bind the listening server socket. */
listen_sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP);
test_bind(listen_sk, &svr_loop.sa, sizeof(svr_loop));
/* Mark listen_sk as being able to accept new associations. */
test_listen(listen_sk, MAX_CLIENTS-1);
/* Create and bind the client sockets. */
for (i = 0; i < MAX_CLIENTS; i++) {
clt_sk[i] = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP);
test_bind(clt_sk[i], &clt_loop[i].sa, sizeof(clt_loop[i]));
}
clt2_sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP);
test_bind(clt2_sk, &clt2_loop.sa, sizeof(clt2_loop));
addrlen = sizeof(accept_loop);
/* Try to do accept on a non-listening socket. It should fail. */
error = accept(clt_sk[0], &accept_loop.sa, &addrlen);
if ((-1 != error) && (EINVAL != errno))
tst_brkm(TBROK, tst_exit, "accept on non-listening socket "
"error:%d, errno:%d", error, errno);
tst_resm(TPASS, "accept on non-listening socket");
/* Try to do a connect from a listening socket. It should fail. */
error = connect(listen_sk, (struct sockaddr *)&clt_loop[0],
sizeof(clt_loop[0]));
if ((-1 != error) && (EISCONN != errno))
tst_brkm(TBROK, tst_exit, "connect to non-listening socket "
"error:%d, errno:%d", error, errno);
tst_resm(TPASS, "connect to non-listening socket");
/* Do a blocking connect from clt_sk's to listen_sk */
for (i = 0; i < MAX_CLIENTS; i++)
test_connect(clt_sk[i], &svr_loop.sa, sizeof(svr_loop));
tst_resm(TPASS, "connect to listening socket");
/* Verify that no more connect's can be done after the acceptq
* backlog has reached the max value.
*/
error = connect(clt2_sk, &svr_loop.sa, sizeof(svr_loop));
if ((-1 != error) && (ECONNREFUSED != errno))
tst_brkm(TBROK, tst_exit, "connect after max backlog "
"error:%d, errno:%d", error, errno);
tst_resm(TPASS, "connect after max backlog");
/* Extract the associations on the listening socket as new sockets. */
for (i = 0; i < MAX_CLIENTS; i++) {
poll_fd.fd = listen_sk;
poll_fd.events = POLLIN;
poll_fd.revents = 0;
error = poll(&poll_fd, 1, -1);
if ((1 != error) && (1 != poll_fd.revents))
tst_brkm(TBROK, tst_exit, "Unexpected return value "
"with poll, error:%d errno:%d, revents:%d",
error, errno, poll_fd.revents);
addrlen = sizeof(accept_loop);
accept_sk[i] = test_accept(listen_sk, &accept_loop.sa,
&addrlen);
}
tst_resm(TPASS, "accept from listening socket");
/* Try to do a connect on an established socket. It should fail. */
error = connect(accept_sk[0], &clt_loop[0].sa, sizeof(clt_loop[0]));
if ((-1 != error) || (EISCONN != errno))
tst_brkm(TBROK, tst_exit, "connect on an established socket "
"error:%d errno:%d", error, errno);
tst_resm(TPASS, "connect on an established socket");
/* Try to do accept on an established socket. It should fail. */
error = accept(accept_sk[0], &accept_loop.sa, &addrlen);
if ((-1 != error) && (EINVAL != errno))
tst_brkm(TBROK, tst_exit, "accept on an established socket "
"error:%d errno:%d", error, errno);
error = accept(clt_sk[0], &accept_loop.sa, &addrlen);
if ((-1 != error) && (EINVAL != errno))
tst_brkm(TBROK, tst_exit, "accept on an established socket "
"failure: error:%d errno:%d", error, errno);
tst_resm(TPASS, "accept on an established socket");
/* Send and receive a message from the client sockets to the accepted
* sockets.
*/
for (i = 0; i < MAX_CLIENTS; i++) {
test_send(clt_sk[i], message, strlen(message), 0);
test_recv(accept_sk[i], msgbuf, 100, 0);
}
tst_resm(TPASS, "client sockets -> accepted sockets");
/* Send and receive a message from the accepted sockets to the client
* sockets.
*/
for (i = 0; i < MAX_CLIENTS; i++) {
test_send(accept_sk[i], message, strlen(message), 0);
test_recv(clt_sk[i], msgbuf, 100, 0);
}
tst_resm(TPASS, "accepted sockets -> client sockets");
/* Sending a message on a listening socket should fail. */
error = send(listen_sk, message, strlen(message), MSG_NOSIGNAL);
if ((-1 != error) || (EPIPE != errno))
tst_brkm(TBROK, tst_exit, "send on a listening socket "
"error:%d, errno:%d", error, errno);
tst_resm(TPASS, "send on a listening socket");
/* Trying to receive a message on a listening socket should fail. */
error = recv(listen_sk, msgbuf, 100, 0);
if ((-1 != error) || (ENOTCONN != errno))
tst_brkm(TBROK, tst_exit, "recv on a listening socket "
"error:%d, errno:%d", error, errno);
tst_resm(TPASS, "recv on a listening socket");
/* TESTCASES for shutdown() */
errno = 0;
test_send(accept_sk[0], message, strlen(message), 0);
/* Enable ASSOC_CHANGE and SNDRCVINFO notifications. */
test_enable_assoc_change(clt_sk[0]);
/* Do a SHUT_WR on clt_sk[0] to disable any new sends. */
test_shutdown(clt_sk[0], SHUT_WR);
/* Reading on a socket that has received SHUTDOWN should return 0
* indicating EOF.
*/
error = recv(accept_sk[0], msgbuf, 100, 0);
if ((0 != error) || (0 != errno))
tst_brkm(TBROK, tst_exit, "recv on a SHUTDOWN received socket "
"error:%d errno:%d", error, errno);
tst_resm(TPASS, "recv on a SHUTDOWN received socket");
/* Read the pending message on clt_sk[0] that was received before
* SHUTDOWN call.
*/
test_recv(clt_sk[0], msgbuf, 100, 0);
/* Initialize inmessage for all receives. */
big_buffer = test_malloc(REALLY_BIG);
memset(&inmessage, 0, sizeof(inmessage));
iov.iov_base = big_buffer;
iov.iov_len = REALLY_BIG;
inmessage.msg_iov = &iov;
inmessage.msg_iovlen = 1;
inmessage.msg_control = incmsg;
inmessage.msg_controllen = sizeof(incmsg);
/* Receive the SHUTDOWN_COMP notification as they are enabled. */
error = test_recvmsg(clt_sk[0], &inmessage, MSG_WAITALL);
test_check_msg_notification(&inmessage, error,
sizeof(struct sctp_assoc_change),
SCTP_ASSOC_CHANGE, SCTP_SHUTDOWN_COMP);
tst_resm(TPASS, "recv SHUTDOWN_COMP notification on a SHUT_WR socket");
/* No more messages and the association is SHUTDOWN, should fail. */
error = recv(clt_sk[0], msgbuf, 100, 0);
if ((-1 != error) || (ENOTCONN != errno))
tst_brkm(TBROK, tst_exit, "recv on a SHUTDOWN sent socket "
"error:%d, errno:%d", error, errno);
tst_resm(TPASS, "recv on a SHUTDOWN sent socket");
errno = 0;
/* Do a SHUT_RD on clt_sk[1] to disable any new receives. */
test_shutdown(clt_sk[1], SHUT_RD);
error = recv(clt_sk[1], msgbuf, 100, 0);
if ((0 != error) || (0 != errno))
tst_brkm(TBROK, tst_exit, "recv on a SHUT_RD socket "
"error:%d, errno:%d", error, errno);
/* Sending a message on SHUT_RD socket. */
test_send(clt_sk[1], message, strlen(message), 0);
/* Receive the message sent on SHUT_RD socket. */
test_recv(accept_sk[1], msgbuf, 100, 0);
/* Send a message to the SHUT_RD socket. */
test_send(accept_sk[1], message, strlen(message), 0);
/* We should not receive the message as the socket is SHUT_RD */
error = recv(clt_sk[1], msgbuf, 100, 0);
if ((0 != error) || (0 != errno))
tst_brkm(TBROK, tst_exit, "recv on a SHUT_RD socket "
"error:%d, errno:%d", error, errno);
tst_resm(TPASS, "recv on a SHUT_RD socket");
/* Do a SHUT_RDWR on clt_sk[2] to disable any new sends/receives. */
test_shutdown(clt_sk[2], SHUT_RDWR);
error = recv(accept_sk[2], msgbuf, 100, 0);
if ((0 != error) || (0 != errno))
tst_brkm(TBROK, tst_exit, "recv on a SHUT_RDWR socket "
"error:%d, errno:%d", error, errno);
error = recv(clt_sk[2], msgbuf, 100, 0);
if ((0 != error) || (0 != errno))
tst_brkm(TBROK, tst_exit, "recv on a SHUT_RDWR socket "
"error:%d, errno:%d", error, errno);
tst_resm(TPASS, "recv on a SHUT_RDWR socket");
error = 0;
for (i = 0; i < MAX_CLIENTS; i++)
close(clt_sk[i]);
for (i = 0; i < MAX_CLIENTS; i++)
close(accept_sk[i]);
/* Test case to verify accept of a CLOSED association. */
/* Do a connect, send and a close to ESTABLISH and CLOSE an
* association on the listening socket.
*/
test_connect(clt2_sk, &svr_loop.sa, sizeof(svr_loop));
test_send(clt2_sk, message, strlen(message), 0);
close(clt2_sk);
FD_ZERO(&set);
FD_SET(listen_sk, &set);
error = select(listen_sk + 1, &set, NULL, NULL, NULL);
if (1 != error)
tst_brkm(TBROK, tst_exit, "select error:%d, "
"errno: %d", error, errno);
/* Now accept the CLOSED association waiting on the listening
* socket.
*/
accept2_sk = test_accept(listen_sk, &accept_loop.sa, &addrlen);
/* Receive the message sent before doing a close. */
test_recv(accept2_sk, msgbuf, 100, 0);
/* Receive EOF indication as there are no more messages and the
* socket is SHUTDOWN.
*/
error = recv(accept2_sk, msgbuf, 100, 0);
if ((0 != error) || (0 != errno))
tst_brkm(TBROK, tst_exit, "Unexpected error return on "
"recv(error:%d, errno:%d)", error, errno);
tst_resm(TPASS, "accept of a CLOSED association");
/* Trying to send a message over the CLOSED association should
* generate EPIPE.
*/
error = send(accept2_sk, message, strlen(message), MSG_NOSIGNAL);
if ((-1 != error) || (EPIPE != errno))
tst_brkm(TBROK, tst_exit, "send to a CLOSED association "
"error:%d, errno:%d", error, errno);
tst_resm(TPASS, "send to a CLOSED association");
error = 0;
close(accept2_sk);
/* Verify that auto-connect can be done on a TCP-style socket using
* sendto/sendmsg.
*/
clt2_sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP);
test_bind(clt2_sk, &clt2_loop.sa, sizeof(clt2_loop));
/* Do a sendto() without a connect() */
test_sendto(clt2_sk, message, strlen(message), 0, &svr_loop.sa,
sizeof(svr_loop));
accept2_sk = test_accept(listen_sk, &accept_loop.sa, &addrlen);
test_recv(accept2_sk, msgbuf, 100, 0);
tst_resm(TPASS, "auto-connect using sendto");
outmessage.msg_name = &svr_loop;
outmessage.msg_namelen = sizeof(svr_loop);
outmessage.msg_iov = NULL;
outmessage.msg_iovlen = 0;
outmessage.msg_control = outcmsg;
outmessage.msg_controllen = sizeof(outcmsg);
outmessage.msg_flags = 0;
cmsg = CMSG_FIRSTHDR(&outmessage);
cmsg->cmsg_level = IPPROTO_SCTP;
cmsg->cmsg_type = SCTP_SNDRCV;
cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo));
outmessage.msg_controllen = cmsg->cmsg_len;
sinfo = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);
memset(sinfo, 0x00, sizeof(struct sctp_sndrcvinfo));
/* Verify that SCTP_EOF cannot be used to shutdown an association
* on a TCP-style socket.
*/
sinfo->sinfo_flags |= SCTP_EOF;
error = sendmsg(clt2_sk, &outmessage, 0);
if ((-1 != error) || (EINVAL != errno))
tst_brkm(TBROK, tst_exit, "sendmsg with SCTP_EOF flag "
"error:%d, errno:%d", error, errno);
tst_resm(TPASS, "sendmsg with SCTP_EOF flag");
/* Verify that SCTP_ABORT cannot be used to abort an association
* on a TCP-style socket.
*/
sinfo->sinfo_flags |= SCTP_ABORT;
error = sendmsg(clt2_sk, &outmessage, 0);
if ((-1 != error) || (EINVAL != errno))
tst_brkm(TBROK, tst_exit, "sendmsg with SCTP_ABORT flag "
"error:%d, errno:%d", error, errno);
tst_resm(TPASS, "sendmsg with SCTP_ABORT flag");
/* Verify that a normal message can be sent using sendmsg. */
outmessage.msg_iov = &out_iov;
outmessage.msg_iovlen = 1;
out_iov.iov_base = message;
out_iov.iov_len = strlen(message) + 1;
sinfo->sinfo_flags = 0;
test_sendmsg(clt2_sk, &outmessage, 0, strlen(message)+1);
test_recv(accept2_sk, msgbuf, 100, 0);
tst_resm(TPASS, "sendmsg with no flags");
close(clt2_sk);
close(accept2_sk);
close(listen_sk);
/* Indicate successful completion. */
return 0;
}
int main(int argc, char **argv) {
int help=0;
int arg=1;
gasnet_handlerentry_t htable[] = {
{ hidx_ping_shorthandler, ping_shorthandler },
{ hidx_pong_shorthandler, pong_shorthandler },
{ hidx_ping_medhandler, ping_medhandler },
{ hidx_pong_medhandler, pong_medhandler },
{ hidx_ping_longhandler, ping_longhandler },
{ hidx_pong_longhandler, pong_longhandler },
{ hidx_ping_shorthandler_flood, ping_shorthandler_flood },
{ hidx_pong_shorthandler_flood, pong_shorthandler_flood },
{ hidx_ping_medhandler_flood, ping_medhandler_flood },
{ hidx_pong_medhandler_flood, pong_medhandler_flood },
{ hidx_ping_longhandler_flood, ping_longhandler_flood },
{ hidx_pong_longhandler_flood, pong_longhandler_flood },
{ hidx_done_shorthandler, done_shorthandler }
};
GASNET_Safe(gasnet_init(&argc, &argv));
mynode = gasnet_mynode();
numnode = gasnet_nodes();
arg = 1;
while (argc > arg) {
if (!strcmp(argv[arg], "-p")) {
#if GASNET_PAR
pollers = test_thread_limit(atoi(argv[arg+1])+1)-1;
arg += 2;
#else
if (0 == mynode) {
fprintf(stderr, "testam %s\n", GASNET_CONFIG_STRING);
fprintf(stderr, "ERROR: The -p option is only available in the PAR configuration.\n");
fflush(NULL);
}
sleep(1);
gasnet_exit(1);
#endif
} else if (!strcmp(argv[arg], "-in")) {
insegment = 1;
++arg;
} else if (!strcmp(argv[arg], "-out")) {
insegment = 0;
++arg;
} else if (!strcmp(argv[arg], "-c")) {
crossmachinemode = 1;
++arg;
} else if (!strcmp(argv[arg], "-src-noop")) {
src_mode = SRC_NOOP;
++arg;
} else if (!strcmp(argv[arg], "-src-generate")) {
src_mode = SRC_GENERATE;
++arg;
} else if (!strcmp(argv[arg], "-src-memcpy")) {
src_mode = SRC_MEMCPY;
++arg;
} else if (argv[arg][0] == '-') {
help = 1;
++arg;
} else break;
}
if (argc > arg) { iters = atoi(argv[arg]); ++arg; }
if (!iters) iters = 1000;
if (argc > arg) { maxsz = atoi(argv[arg]); ++arg; }
if (!maxsz) maxsz = 2*1024*1024;
if (argc > arg) { TEST_SECTION_PARSE(argv[arg]); ++arg; }
GASNET_Safe(gasnet_attach(htable, sizeof(htable)/sizeof(gasnet_handlerentry_t),
TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET));
#if GASNET_PAR
#define PAR_USAGE \
" The -p option gives the number of polling threads, specified as\n" \
" a non-negative integer argument (default is no polling threads).\n"
#else
#define PAR_USAGE ""
#endif
test_init("testam", 1, "[options] (iters) (maxsz) (test_sections)\n"
" The '-in' or '-out' option selects whether the requestor's\n"
" buffer is in the GASNet segment or not (default is 'in').\n"
PAR_USAGE
" The '-src-*' options select treatment of the payload buffer used for\n"
" Medium and Long AMs, as follows:\n"
" -src-noop: no per-operation initialization (default)\n"
" -src-generate: initialized (w/o memory reads) on each AM injection\n"
" -src-memcpy: initialized using memcpy() on each AM injection\n"
" The -c option enables cross-machine pairing (default is nearest neighbor).\n");
if (help || argc > arg) test_usage();
TEST_PRINT_CONDUITINFO();
if (insegment) {
myseg = TEST_MYSEG();
} else {
char *space = test_malloc(alignup(maxsz,PAGESZ) + PAGESZ);
myseg = alignup_ptr(space, PAGESZ);
}
maxmed = MIN(maxsz, gasnet_AMMaxMedium());
maxlongreq = MIN(maxsz, gasnet_AMMaxLongRequest());
maxlongrep = MIN(maxsz, gasnet_AMMaxLongReply());
if (src_mode == SRC_MEMCPY) {
zero_buffer = test_calloc(maxsz, 1);
}
if (crossmachinemode) {
if ((numnode%2) && (mynode == numnode-1)) {
sender = 1;
peer = mynode;
} else {
gasnet_node_t half = numnode / 2;
sender = (mynode < half);
peer = sender ? (mynode + half) : (mynode - half);
}
} else {
peer = mynode ^ 1;
sender = mynode % 2 == 0;
if (peer == numnode) {
peer = mynode;
}
}
recvr = !sender || (peer == mynode);
// Long Request and Reply (distinct for loopback)
reply_addr = TEST_SEG(peer);
request_addr = (peer == mynode) ? (void*)((uintptr_t)reply_addr + alignup(maxsz,SIZEOF_GASNET_REGISTER_VALUE_T))
: reply_addr;
BARRIER();
#if GASNET_PAR
#define PAR_FMT " %i extra recvr polling threads\n"
#define PAR_ARG ,pollers
#else
#define PAR_FMT /*empty*/
#define PAR_ARG /*empty*/
#endif
if (mynode == 0) {
printf("Running %i iterations of %s AM performance with:\n"
" local addresses %sside the segment%s\n"
" %s\n"
PAR_FMT
" ...\n",
iters,
(crossmachinemode ? "cross-machine ": ""),
(insegment ? "in" : "out"),
(insegment ? " (default)" : ""),
((src_mode == SRC_NOOP) ? "no payload initialization (default)"
:(src_mode == SRC_GENERATE) ? "payload initialized by computation"
: "payload initialized using memcpy()")
PAR_ARG
);
printf(" Msg Sz Description Total time Avg. time Bandwidth\n"
" ------ ----------- ---------- --------- ---------\n");
fflush(stdout);
}
#if GASNET_PAR
TEST_SET_WAITMODE(pollers+1);
if (pollers)
test_createandjoin_pthreads(pollers+1,doAll,NULL,0);
else
#endif
doAll(NULL);
MSG("done.");
gasnet_exit(0);
return 0;
}
int main(int argc, char **argv) {
int arg = 1, help = 0;
gasnet_handlerentry_t htable[] = {
{ hidx_ping_medhandler, ping_medhandler },
{ hidx_pong_medhandler, pong_medhandler },
{ hidx_ping_longhandler, ping_longhandler },
{ hidx_pong_longhandler, pong_longhandler },
{ hidx_ping_alonghandler, ping_alonghandler },
};
/* call startup */
GASNET_Safe(gasnet_init(&argc, &argv));
#define AMOPT() if (!amopt) { amopt = 1; domed = 0; dolong = 0; dolongasync = 0; }
while (argc > arg) {
if (!strcmp(argv[arg], "-p")) {
doprime = 1;
++arg;
} else if (!strcmp(argv[arg], "-u")) {
dosizesync = 0;
++arg;
} else if (!strcmp(argv[arg], "-s")) {
domultith = 0;
++arg;
} else if (!strcmp(argv[arg], "-n")) {
allowretry = 0;
++arg;
} else if (!strcmp(argv[arg], "-in")) {
doinseg = 1; dooutseg = 0;
++arg;
} else if (!strcmp(argv[arg], "-out")) {
doinseg = 0; dooutseg = 1;
++arg;
} else if (!strcmp(argv[arg], "-m")) {
AMOPT();
domed = 1;
++arg;
} else if (!strcmp(argv[arg], "-l")) {
AMOPT();
dolong = 1;
++arg;
} else if (!strcmp(argv[arg], "-a")) {
AMOPT();
dolongasync = 1;
++arg;
} else if (argv[arg][0] == '-') {
help = 1;
++arg;
} else break;
}
if (argc > arg) { iters = atoi(argv[arg]); arg++; }
if (!iters) iters = 10;
if (argc > arg) { max_payload = atoi(argv[arg]); arg++; }
if (!max_payload) max_payload = 1024*1024;
if (argc > arg) { depth = atoi(argv[arg]); arg++; }
if (!depth) depth = 16;
/* round down to largest payload AM allows */
maxlong = MIN(gasnet_AMMaxLongRequest(),gasnet_AMMaxLongReply());
max_payload = MIN(max_payload,MAX(gasnet_AMMaxMedium(),maxlong));
GASNET_Safe(gasnet_attach(htable, sizeof(htable)/sizeof(gasnet_handlerentry_t), TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET));
test_init("testcore2",0,"[options] (iters) (max_payload) (depth)\n"
" -m test AMMedium (defaults to all types)\n"
" -l test AMLong (defaults to all types)\n"
" -a test AMLongAsync (defaults to all types)\n"
" -p prime the AMLong transfer areas with puts, to encourage pinning\n"
" -u loosen sychronization to allow diff payload sizes to be in flight at once\n"
" -s single-threaded PAR mode (default is to start a polling thread in PAR mode)\n"
" -n no retry on failure\n"
" -in/-out use only in- or out-of-segment sources for AMLong(Async) (default is both)\n"
);
if (help || argc > arg) test_usage();
TEST_PRINT_CONDUITINFO();
/* get SPMD info */
myproc = gasnet_mynode();
numprocs = gasnet_nodes();
peerproc = myproc ^ 1;
if (peerproc == gasnet_nodes()) {
/* w/ odd # of nodes, last one talks to self */
peerproc = myproc;
}
myseg = TEST_MYSEG();
peerreqseg = TEST_SEG(peerproc);
peerrepseg = peerreqseg+max_payload*depth*2;
localseg = myseg + max_payload*depth*4;
assert_always(TEST_SEGSZ >= max_payload*depth*5);
privateseg = test_malloc(max_payload*depth*3); /* out-of-seg request src, long reply src, along reply src */
longreplysrc = privateseg+max_payload*depth;
alongreplysrc = privateseg+max_payload*depth*2;
#ifdef GASNET_PAR
if (domultith) test_createandjoin_pthreads(2,doit,NULL,0);
else
#endif
doit(0);
BARRIER();
test_free(privateseg);
MSG("done. (detected %i errs)", test_errs);
gasnet_exit(test_errs > 0 ? 1 : 0);
return 0;
}
int
main(int argc, char *argv[])
{
int svr_sk, clt_sk1, clt_sk2, peeloff_sk;
sctp_assoc_t svr_associd1, svr_associd2, clt_associd1, clt_associd2;
struct iovec iov;
struct msghdr inmessage;
int error, i;
struct sctp_assoc_change *sac;
char *big_buffer;
int flags;
struct sockaddr_in svr_loop[NUMADDR];
struct sockaddr_in svr_try[NUMADDR];
struct sockaddr_in clt_loop1[NUMADDR];
struct sockaddr_in clt_loop2[NUMADDR];
struct sockaddr_in clt_loop3[NUMADDR];
sockaddr_storage_t svr_test[NUMADDR], clt_test1[NUMADDR], clt_test2[NUMADDR];
/* Rather than fflush() throughout the code, set stdout to
* be unbuffered.
*/
setvbuf(stdout, NULL, _IONBF, 0);
for (i = 0; i < NUMADDR; i++) {
/* Initialize the server and client addresses. */
svr_loop[i].sin_family = AF_INET;
svr_loop[i].sin_addr.s_addr = SCTP_IP_LOOPBACK_I(i);
svr_loop[i].sin_port = htons(SCTP_TESTPORT_1);
svr_test[i].v4.sin_family = AF_INET;
svr_test[i].v4.sin_addr.s_addr = SCTP_IP_LOOPBACK_I(i);
svr_test[i].v4.sin_port = htons(SCTP_TESTPORT_1);
svr_try[i].sin_family = AF_INET;
if (i < (NUMADDR-1)) {
svr_try[i].sin_addr.s_addr = SCTP_IP_LOOPBACK_I(i);
} else {
/* Make last address invalid. */
svr_try[i].sin_addr.s_addr = SCTP_IP_LOOPBACK_I(i + 0x400);
}
svr_try[i].sin_port = htons(SCTP_TESTPORT_1);
clt_loop1[i].sin_family = AF_INET;
clt_loop1[i].sin_addr.s_addr = SCTP_IP_LOOPBACK_I(i + 0x100);
clt_loop1[i].sin_port = htons(SCTP_TESTPORT_2);
clt_test1[i].v4.sin_family = AF_INET;
clt_test1[i].v4.sin_addr.s_addr = SCTP_IP_LOOPBACK_I(i + 0x100);
clt_test1[i].v4.sin_port = htons(SCTP_TESTPORT_2);
clt_loop2[i].sin_family = AF_INET;
clt_loop2[i].sin_addr.s_addr = SCTP_IP_LOOPBACK_I(i + 0x200);
clt_loop2[i].sin_port = htons(SCTP_TESTPORT_2+1);
clt_test2[i].v4.sin_family = AF_INET;
clt_test2[i].v4.sin_addr.s_addr = SCTP_IP_LOOPBACK_I(i + 0x200);
clt_test2[i].v4.sin_port = htons(SCTP_TESTPORT_2+1);
clt_loop3[i].sin_family = AF_INET;
clt_loop3[i].sin_addr.s_addr = SCTP_IP_LOOPBACK_I(i + 0x300);
clt_loop3[i].sin_port = htons(SCTP_TESTPORT_2+2);
}
/* Create and bind the server socket. */
svr_sk = test_socket(AF_INET, SOCK_SEQPACKET, IPPROTO_SCTP);
test_bind(svr_sk, (struct sockaddr *)&svr_loop[0], sizeof(svr_loop[0]));
test_bindx_add(svr_sk, (struct sockaddr *)&svr_loop[1], NUMADDR-1);
/* Mark server socket as being able to accept new associations. */
test_listen(svr_sk, 1);
/* Create and bind the client sockets. */
clt_sk1 = test_socket(AF_INET, SOCK_SEQPACKET, IPPROTO_SCTP);
test_bind(clt_sk1, (struct sockaddr *)&clt_loop1[0], sizeof(clt_loop1));
test_bindx_add(clt_sk1, (struct sockaddr *)&clt_loop1[1], NUMADDR-1);
clt_sk2 = test_socket(AF_INET, SOCK_SEQPACKET, IPPROTO_SCTP);
test_bind(clt_sk2, (struct sockaddr *)&clt_loop2[0], sizeof(clt_loop2));
test_bindx_add(clt_sk2, (struct sockaddr *)&clt_loop2[1], NUMADDR-1);
/* Enable ASSOC_CHANGE and SNDRCVINFO notifications. */
test_enable_assoc_change(svr_sk);
test_enable_assoc_change(clt_sk1);
test_enable_assoc_change(clt_sk2);
/* Set clt_sk1 as non-blocking. */
flags = fcntl(clt_sk1, F_GETFL, 0);
if (flags < 0)
tst_brkm(TBROK, tst_exit, "fcntl F_GETFL: %s", strerror(errno));
if (fcntl(clt_sk1, F_SETFL, flags | O_NONBLOCK) < 0)
tst_brkm(TBROK, tst_exit, "fcntl F_SETFL: %s", strerror(errno));
/* Do a non-blocking connectx from clt_sk1 to svr_sk */
error = sctp_connectx(clt_sk1, (struct sockaddr *)svr_try, NUMADDR);
/* Non-blocking connectx should return immediately with EINPROGRESS. */
if ((error != -1) || (EINPROGRESS != errno))
tst_brkm(TBROK, tst_exit, "non-blocking connectx error: %d"
"errno:%d", error, errno);
tst_resm(TPASS, "non-blocking connectx");
/* Doing a connectx on a socket to create an association that is
* is already established should return EISCONN.
*/
error = sctp_connectx(clt_sk1, (struct sockaddr *)svr_try, NUMADDR);
if ((error != -1) || (EISCONN != errno))
tst_brkm(TBROK, tst_exit, "connectx on a socket to create an "
"assoc that is already established error:%d errno:%d",
error, errno);
tst_resm(TPASS, "connectx on a socket to create an assoc that is "
"already established");
/* Initialize inmessage for all receives. */
memset(&inmessage, 0, sizeof(inmessage));
big_buffer = test_malloc(REALLY_BIG);
iov.iov_base = big_buffer;
iov.iov_len = REALLY_BIG;
inmessage.msg_iov = &iov;
inmessage.msg_iovlen = 1;
inmessage.msg_control = NULL;
/* Get COMM_UP on clt_sk1 */
error = test_recvmsg(clt_sk1, &inmessage, MSG_WAITALL);
test_check_msg_notification(&inmessage, error,
sizeof(struct sctp_assoc_change),
SCTP_ASSOC_CHANGE, SCTP_COMM_UP);
sac = (struct sctp_assoc_change *)iov.iov_base;
clt_associd1 = sac->sac_assoc_id;
/* Get COMM_UP on svr_sk */
error = test_recvmsg(svr_sk, &inmessage, MSG_WAITALL);
test_check_msg_notification(&inmessage, error,
sizeof(struct sctp_assoc_change),
SCTP_ASSOC_CHANGE, SCTP_COMM_UP);
sac = (struct sctp_assoc_change *)iov.iov_base;
svr_associd1 = sac->sac_assoc_id;
/* Do a blocking connectx from clt_sk2 to svr_sk.
* Blocking connectx should block until the association is established
* and return success.
*/
test_connectx(clt_sk2, (struct sockaddr *)svr_try, NUMADDR);
/* Get COMM_UP on clt_sk2 */
error = test_recvmsg(clt_sk2, &inmessage, MSG_WAITALL);
test_check_msg_notification(&inmessage, error,
sizeof(struct sctp_assoc_change),
SCTP_ASSOC_CHANGE, SCTP_COMM_UP);
sac = (struct sctp_assoc_change *)iov.iov_base;
clt_associd2 = sac->sac_assoc_id;
/* Get COMM_UP on svr_sk */
error = test_recvmsg(svr_sk, &inmessage, MSG_WAITALL);
test_check_msg_notification(&inmessage, error,
sizeof(struct sctp_assoc_change),
SCTP_ASSOC_CHANGE, SCTP_COMM_UP);
sac = (struct sctp_assoc_change *)iov.iov_base;
svr_associd2 = sac->sac_assoc_id;
tst_resm(TPASS, "blocking connectx");
peeloff_sk = test_sctp_peeloff(svr_sk, svr_associd1);
/* Doing a connectx on a peeled off socket should fail. */
error = sctp_connectx(peeloff_sk, (struct sockaddr *)clt_loop3, NUMADDR);
if ((error != -1) || (EISCONN != errno))
tst_brkm(TBROK, tst_exit, "connectx on a peeled off socket "
"error:%d, errno:%d", error, errno);
tst_resm(TPASS, "connectx on a peeled off socket");
/* Trying to create an association on a socket that matches an
* existing peeled-off association should fail.
*/
error = sctp_connectx(svr_sk, (struct sockaddr *)clt_loop1, NUMADDR);
if ((error != -1) || (EADDRNOTAVAIL != errno))
tst_brkm(TBROK, tst_exit, "connectx to create an assoc that "
"matches a peeled off assoc error:%d errno:%d",
error, errno);
tst_resm(TPASS, "connectx to create an assoc that matches a peeled off "
"assoc");
test_peer_addr(peeloff_sk, svr_associd1, clt_test1, NUMADDR);
tst_resm(TPASS, "server association 1 peers ok");
test_peer_addr(svr_sk, svr_associd2, clt_test2, NUMADDR);
tst_resm(TPASS, "server association 2 peers ok");
test_peer_addr(clt_sk1, clt_associd1, svr_test, NUMADDR);
tst_resm(TPASS, "client association 1 peers ok");
test_peer_addr(clt_sk2, clt_associd2, svr_test, NUMADDR);
tst_resm(TPASS, "client association 2 peers ok");
close(svr_sk);
close(clt_sk1);
close(clt_sk2);
close(peeloff_sk);
/* Indicate successful completion. */
return 0;
}