TEST(pthread, pthread_attr_setguardsize) {
pthread_attr_t attributes;
ASSERT_EQ(0, pthread_attr_init(&attributes));
// Get the default guard size.
size_t default_guard_size;
ASSERT_EQ(0, pthread_attr_getguardsize(&attributes, &default_guard_size));
// No such thing as too small: will be rounded up to one page by pthread_create.
ASSERT_EQ(0, pthread_attr_setguardsize(&attributes, 128));
size_t guard_size;
ASSERT_EQ(0, pthread_attr_getguardsize(&attributes, &guard_size));
ASSERT_EQ(128U, guard_size);
ASSERT_EQ(4096U, GetActualGuardSize(attributes));
// Large enough and a multiple of the page size.
ASSERT_EQ(0, pthread_attr_setguardsize(&attributes, 32*1024));
ASSERT_EQ(0, pthread_attr_getguardsize(&attributes, &guard_size));
ASSERT_EQ(32*1024U, guard_size);
// Large enough but not a multiple of the page size; will be rounded up by pthread_create.
ASSERT_EQ(0, pthread_attr_setguardsize(&attributes, 32*1024 + 1));
ASSERT_EQ(0, pthread_attr_getguardsize(&attributes, &guard_size));
ASSERT_EQ(32*1024U + 1, guard_size);
}
extern "C" void __libc_init_main_thread_late() {
__init_bionic_tls_ptrs(__get_bionic_tcb(), __allocate_temp_bionic_tls());
// Tell the kernel to clear our tid field when we exit, so we're like any other pthread.
// For threads created by pthread_create, this setup happens during the clone syscall (i.e.
// CLONE_CHILD_CLEARTID).
__set_tid_address(&main_thread.tid);
pthread_attr_init(&main_thread.attr);
// We don't want to explicitly set the main thread's scheduler attributes (http://b/68328561).
pthread_attr_setinheritsched(&main_thread.attr, PTHREAD_INHERIT_SCHED);
// The main thread has no guard page.
pthread_attr_setguardsize(&main_thread.attr, 0);
// User code should never see this; we'll compute it when asked.
pthread_attr_setstacksize(&main_thread.attr, 0);
// The TLS stack guard is set from the global, so ensure that we've initialized the global
// before we initialize the TLS. Dynamic executables will initialize their copy of the global
// stack protector from the one in the main thread's TLS.
__libc_safe_arc4random_buf(&__stack_chk_guard, sizeof(__stack_chk_guard));
__init_tcb_stack_guard(__get_bionic_tcb());
__init_thread(&main_thread);
__init_additional_stacks(&main_thread);
}
static void wpool_init(WTHREAD *wp,int num)
{
int i;
if(wp->QP) return;
wp->QP=(Qpool *)malloc(num * sizeof(Qpool));
if(!wp->QP) {
ShowLog(1,"%s:QP malloc error!",__FUNCTION__);
wp->poolnum=0;
return;
}
wp->poolnum=num;
for(i=0;i<wp->poolnum;i++) {
wp->QP[i].queue=NULL;
wp->QP[i].tid=0;
pthread_mutex_init(&wp->QP[i].mut,NULL);
pthread_cond_init(&wp->QP[i].cond,NULL);
}
i=pthread_attr_setdetachstate(&wp->attr,PTHREAD_CREATE_DETACHED);
if(i) {
ShowLog(1,"%s:can't set pthread attr PTHREAD_CREATE_DETACHED:%s",
__FUNCTION__,strerror(i));
}
//设置线程堆栈保护区 16K
pthread_attr_setguardsize(&wp->attr,(size_t)(1024 * 16));
}
void
clone_attributes(pthread_attr_t *new_attr, pthread_attr_t *old_attr)
{
struct sched_param param;
void *addr;
size_t size;
int value;
(void) pthread_attr_init(new_attr);
if (old_attr != NULL) {
(void) pthread_attr_getstack(old_attr, &addr, &size);
/* don't allow a non-NULL thread stack address */
(void) pthread_attr_setstack(new_attr, NULL, size);
(void) pthread_attr_getscope(old_attr, &value);
(void) pthread_attr_setscope(new_attr, value);
(void) pthread_attr_getinheritsched(old_attr, &value);
(void) pthread_attr_setinheritsched(new_attr, value);
(void) pthread_attr_getschedpolicy(old_attr, &value);
(void) pthread_attr_setschedpolicy(new_attr, value);
(void) pthread_attr_getschedparam(old_attr, ¶m);
(void) pthread_attr_setschedparam(new_attr, ¶m);
(void) pthread_attr_getguardsize(old_attr, &size);
(void) pthread_attr_setguardsize(new_attr, size);
}
/* make all pool threads be detached threads */
(void) pthread_attr_setdetachstate(new_attr, PTHREAD_CREATE_DETACHED);
}
int
main (int argc, char *argv[])
{
error_t err;
pid_t child;
child = fork ();
switch (child)
{
case -1:
error (1, errno, "fork");
break;
case 0:
{
pthread_attr_t attr;
pthread_t tid;
void *ret;
err = pthread_attr_init (&attr);
assert_perror (err);
err = pthread_attr_getstacksize (&attr, &stacksize);
assert_perror (err);
err = pthread_attr_setguardsize (&attr, stacksize / 2);
if (err == ENOTSUP)
{
printf ("Stack guard attribute not supported.\n");
return 1;
}
assert_perror (err);
err = pthread_create (&tid, &attr, thr, 0);
assert_perror (err);
err = pthread_attr_destroy (&attr);
assert_perror (err);
err = pthread_join (tid, &ret);
/* Should never be successful. */
printf ("Thread did not segfault!?!\n");
assert_perror (err);
return 0;
}
default:
{
pid_t pid;
int status;
pid = waitpid (child, &status, 0);
printf ("pid = %d; child = %d; status = %d\n", pid, child, status);
assert (pid == child);
assert (status != 0);
}
}
return 0;
}
jlong rvmStartThread(Env* env, JavaThread* threadObj) {
Env* newEnv = rvmCreateEnv(env->vm);
if (!newEnv) {
rvmThrowOutOfMemoryError(env); // rvmCreateEnv() doesn't throw OutOfMemoryError if allocation fails
return 0;
}
rvmLockThreadsList();
if (threadObj->threadPtr != 0) {
rvmThrowIllegalStateException(env, "thread has already been started");
rvmUnlockThreadsList();
return 0;
}
Thread* thread = allocThread(env);
if (!thread) {
rvmUnlockThreadsList();
return 0;
}
size_t stackSize = (size_t) threadObj->stackSize;
if (stackSize == 0) {
stackSize = THREAD_DEFAULT_STACK_SIZE;
} else if (stackSize < THREAD_MIN_STACK_SIZE) {
stackSize = THREAD_MIN_STACK_SIZE;
}
stackSize += THREAD_SIGNAL_STACK_SIZE;
stackSize = (stackSize + THREAD_STACK_SIZE_MULTIPLE - 1) & ~(THREAD_STACK_SIZE_MULTIPLE - 1);
pthread_attr_t threadAttr;
pthread_attr_init(&threadAttr);
pthread_attr_setdetachstate(&threadAttr, PTHREAD_CREATE_DETACHED);
pthread_attr_setstacksize(&threadAttr, stackSize);
pthread_attr_setguardsize(&threadAttr, THREAD_STACK_GUARD_SIZE);
ThreadEntryPointArgs args = {0};
args.env = newEnv;
args.thread = thread;
args.threadObj = threadObj;
int err = 0;
if ((err = pthread_create(&thread->pThread, &threadAttr, startThreadEntryPoint, &args)) != 0) {
rvmUnlockThreadsList();
rvmThrowInternalErrorErrno(env, err);
return 0;
}
while (thread->status != THREAD_STARTING) {
pthread_cond_wait(&threadStartCond, &threadsLock);
}
DL_PREPEND(threads, thread);
pthread_cond_broadcast(&threadsChangedCond);
thread->status = THREAD_VMWAIT;
pthread_cond_broadcast(&threadStartCond);
rvmUnlockThreadsList();
return PTR_TO_LONG(thread);
}
//! ************************************************************************************************
//!
//! ************************************************************************************************
bool brr::ThreadAttr::SetGuardSize(size_t guardSize)
{
const int c_result = pthread_attr_setguardsize(&m_attr, guardSize);
if (c_result)
{
BRR_LOGE("pthread_attr_setguardsize() failed, %s", StrErrno(c_result).c_str());
return false;
}
return true;
}
int
ldap_pvt_thread_create( ldap_pvt_thread_t * thread,
int detach,
void *(*start_routine)( void * ),
void *arg)
{
int rtn;
pthread_attr_t attr;
/* Always create the thread attrs, so we can set stacksize if we need to */
#if HAVE_PTHREADS > 5
pthread_attr_init(&attr);
#else
pthread_attr_create(&attr);
#endif
#ifdef LDAP_PVT_THREAD_SET_STACK_SIZE
/* this should be tunable */
pthread_attr_setstacksize( &attr, LDAP_PVT_THREAD_STACK_SIZE );
if ( ldap_int_stackguard )
pthread_attr_setguardsize( &attr, LDAP_PVT_THREAD_STACK_SIZE );
#endif
#if HAVE_PTHREADS > 5
detach = detach ? PTHREAD_CREATE_DETACHED : PTHREAD_CREATE_JOINABLE;
#if HAVE_PTHREADS == 6
pthread_attr_setdetachstate(&attr, &detach);
#else
pthread_attr_setdetachstate(&attr, detach);
#endif
#endif
#if HAVE_PTHREADS < 5
rtn = pthread_create( thread, attr, start_routine, arg );
#else
rtn = pthread_create( thread, &attr, start_routine, arg );
#endif
#if HAVE_PTHREADS > 5
pthread_attr_destroy(&attr);
#else
pthread_attr_delete(&attr);
if( detach ) {
pthread_detach( thread );
}
#endif
#if HAVE_PTHREADS < 7
if ( rtn < 0 ) rtn = errno;
#endif
LDAP_JITTER(33);
return rtn;
}
int
athr_thr_create(
athr_tid *tid,
void *(*func)(void *),
void *arg,
athr_thr_opts *opts) {
athr_thr_wrap_data__ twd;
pthread_attr_t attr;
int res, dres;
// athr_atomic32_init(&twd.result, (athr_sint32_t) -1);
twd.thr_func = func;
twd.arg = arg;
res = pthread_attr_init(&attr);
if (res != 0) {
return res;
}
res = pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
if (res != 0 && res != ENOTSUP) {
goto error;
}
#ifdef ATHR_STACK_GUARD_SIZE
(void) pthread_attr_setguardsize(&attr, ATHR_STACK_GUARD_SIZE);
#endif
res = pthread_attr_setdetachstate(
&attr,
(opts && opts->detached
? PTHREAD_CREATE_DETACHED
: PTHREAD_CREATE_JOINABLE));
if (res != 0) {
goto error;
}
res = pthread_create((pthread_t *)tid, &attr, thr_wrapper, (void*) &twd);
if (res == 0) {
/* TODO : wait for child to initialize... */
}
error:
dres = pthread_attr_destroy(&attr);
if (res == 0) {
res = dres;
}
return res;
}
kthread_t *
zk_thread_create(caddr_t stk, size_t stksize, thread_func_t func, void *arg,
uint64_t len, proc_t *pp, int state, pri_t pri, int detachstate)
{
kthread_t *kt;
pthread_attr_t attr;
char *stkstr;
ASSERT0(state & ~TS_RUN);
ASSERT0(len);
kt = umem_zalloc(sizeof (kthread_t), UMEM_NOFAIL);
kt->t_func = func;
kt->t_arg = arg;
kt->t_pri = pri;
VERIFY0(pthread_attr_init(&attr));
VERIFY0(pthread_attr_setdetachstate(&attr, detachstate));
/*
* We allow the default stack size in user space to be specified by
* setting the ZFS_STACK_SIZE environment variable. This allows us
* the convenience of observing and debugging stack overruns in
* user space. Explicitly specified stack sizes will be honored.
* The usage of ZFS_STACK_SIZE is discussed further in the
* ENVIRONMENT VARIABLES sections of the ztest(1) man page.
*/
if (stksize == 0) {
stkstr = getenv("ZFS_STACK_SIZE");
if (stkstr == NULL)
stksize = TS_STACK_MAX;
else
stksize = MAX(atoi(stkstr), TS_STACK_MIN);
}
VERIFY3S(stksize, >, 0);
stksize = P2ROUNDUP(MAX(stksize, TS_STACK_MIN), PAGESIZE);
/*
* If this ever fails, it may be because the stack size is not a
* multiple of system page size.
*/
VERIFY0(pthread_attr_setstacksize(&attr, stksize));
VERIFY0(pthread_attr_setguardsize(&attr, PAGESIZE));
VERIFY0(pthread_create(&kt->t_tid, &attr, &zk_thread_helper, kt));
VERIFY0(pthread_attr_destroy(&attr));
return (kt);
}
int
pth_attri_set (pth_attri_t *attri, pth_attr_types_t t, void *data) {
int *di = (int *)data;
size_t *ds = (size_t *)data;
if (attri != (pth_attri_t *)NULL) {
switch (t) {
/* pthread_attr_setdetachstate */
case PTH_ATTR_DETACHED:
attri->at |= t;
return pthread_attr_setdetachstate (&(attri->attr),
PTHREAD_CREATE_JOINABLE);
/* pthread_attr_setdetachstate */
case PTH_ATTR_JOINABLE:
attri->at |= t;
return pthread_attr_setdetachstate (&(attri->attr),
PTHREAD_CREATE_DETACHED);
#ifndef LINUX
/* pthread_attr_setstacksize */
case PTH_ATTR_STACKSZ:
attri->at |= t;
return pthread_attr_setstacksize (&(attri->attr), *ds);
/* pthread_attr_setguardsize */
case PTH_ATTR_GUARDSZ:
attri->at |= t;
return pthread_attr_setguardsize (&(attri->attr), *ds);
#endif /* !LINUX */
/* pthread_attr_setschedparam */
case PTH_ATTR_SCHEDPARAM:
attri->at |= t;
return pthread_attr_setschedparam (&(attri->attr),
(struct sched_param *)data);
/* pthread_attr_setinheritsched */
case PTH_ATTR_INSCHEDPARAM:
attri->at |= t;
return pthread_attr_setinheritsched (&(attri->attr), *di);
/* pthread_attr_setschedpolicy */
case PTH_ATTR_SCHEDPOLICY:
attri->at |= t;
return pthread_attr_setschedpolicy (&(attri->attr), *di);
/* pthread_attr_setscope */
case PTH_ATTR_SCOPE:
attri->at |= t;
return pthread_attr_setscope (&(attri->attr), *di);
default:
return CAF_ERROR_SUB;
}
}
return CAF_ERROR_SUB;
}
/*ARGSUSED*/
kthread_t *
zk_thread_create(void (*func)(void *), void *arg, size_t stksize, int state)
{
pthread_attr_t attr;
pthread_t tid;
char *stkstr;
int detachstate = PTHREAD_CREATE_DETACHED;
VERIFY0(pthread_attr_init(&attr));
if (state & TS_JOINABLE)
detachstate = PTHREAD_CREATE_JOINABLE;
VERIFY0(pthread_attr_setdetachstate(&attr, detachstate));
/*
* We allow the default stack size in user space to be specified by
* setting the ZFS_STACK_SIZE environment variable. This allows us
* the convenience of observing and debugging stack overruns in
* user space. Explicitly specified stack sizes will be honored.
* The usage of ZFS_STACK_SIZE is discussed further in the
* ENVIRONMENT VARIABLES sections of the ztest(1) man page.
*/
if (stksize == 0) {
stkstr = getenv("ZFS_STACK_SIZE");
if (stkstr == NULL)
stksize = TS_STACK_MAX;
else
stksize = MAX(atoi(stkstr), TS_STACK_MIN);
}
VERIFY3S(stksize, >, 0);
stksize = P2ROUNDUP(MAX(stksize, TS_STACK_MIN), PAGESIZE);
/*
* If this ever fails, it may be because the stack size is not a
* multiple of system page size.
*/
VERIFY0(pthread_attr_setstacksize(&attr, stksize));
VERIFY0(pthread_attr_setguardsize(&attr, PAGESIZE));
VERIFY0(pthread_create(&tid, &attr, (void *(*)(void *))func, arg));
VERIFY0(pthread_attr_destroy(&attr));
return ((void *)(uintptr_t)tid);
}
/*************************************************
* Function: Pthread_attr_setguardsize()
* Description: 设置线程栈的警戒缓冲区大小包裹函数
* Input: *attr---线程属性结构
guardsize---线程栈警戒缓冲区大小
* Output: *attr---线程属性结构
* Return: 0/errno
*************************************************/
int Pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize)
{
int rval;
if(attr==AII_NULL)
{
return -1;
}
rval = pthread_attr_setguardsize(attr, guardsize);
if (rval != 0)
{
debug_info(DEBUG_LEVEL_4,"Pthread_attr_setguardsize() failed!\n");
}
return rval;
}
void ThreadFactory::setGuardSize(size_t value)
{
int ret = pthread_attr_setguardsize(&attr_, value);
if (ret != 0)
FTL_PTHREAD_EXCEPTION("pthread_attr_setguardsize", ret);
}
static int
do_test (void)
{
int result = 0;
pthread_attr_t a;
cpu_set_t c1, c2;
int err = pthread_attr_init (&a);
if (err)
{
error (0, err, "pthread_attr_init failed");
result = 1;
}
err = pthread_attr_getaffinity_np (&a, sizeof (c1), &c1);
if (err && err != ENOSYS)
{
error (0, err, "pthread_attr_getaffinity_np failed");
result = 1;
}
err = pthread_attr_destroy (&a);
if (err)
{
error (0, err, "pthread_attr_destroy failed");
result = 1;
}
err = pthread_getattr_np (pthread_self (), &a);
if (err)
{
error (0, err, "pthread_getattr_np failed");
result = 1;
}
int detachstate;
err = pthread_attr_getdetachstate (&a, &detachstate);
if (err)
{
error (0, err, "pthread_attr_getdetachstate failed");
result = 1;
}
else if (detachstate != PTHREAD_CREATE_JOINABLE)
{
error (0, 0, "initial thread not joinable");
result = 1;
}
void *stackaddr;
size_t stacksize;
err = pthread_attr_getstack (&a, &stackaddr, &stacksize);
if (err)
{
error (0, err, "pthread_attr_getstack failed");
result = 1;
}
else if ((void *) &a < stackaddr
|| (void *) &a >= stackaddr + stacksize)
{
error (0, 0, "pthread_attr_getstack returned range does not cover main's stack");
result = 1;
}
else
printf ("initial thread stack %p-%p (0x%zx)\n", stackaddr,
stackaddr + stacksize, stacksize);
size_t guardsize;
err = pthread_attr_getguardsize (&a, &guardsize);
if (err)
{
error (0, err, "pthread_attr_getguardsize failed");
result = 1;
}
else if (guardsize != 0)
{
error (0, 0, "pthread_attr_getguardsize returned %zd != 0",
guardsize);
result = 1;
}
int scope;
err = pthread_attr_getscope (&a, &scope);
if (err)
{
error (0, err, "pthread_attr_getscope failed");
result = 1;
}
else if (scope != PTHREAD_SCOPE_SYSTEM)
{
error (0, 0, "pthread_attr_getscope returned %d != PTHREAD_SCOPE_SYSTEM",
scope);
result = 1;
}
int inheritsched;
err = pthread_attr_getinheritsched (&a, &inheritsched);
if (err)
{
error (0, err, "pthread_attr_getinheritsched failed");
result = 1;
}
else if (inheritsched != PTHREAD_INHERIT_SCHED)
{
error (0, 0, "pthread_attr_getinheritsched returned %d != PTHREAD_INHERIT_SCHED",
inheritsched);
result = 1;
}
err = pthread_getaffinity_np (pthread_self (), sizeof (c1), &c1);
if (err == 0)
{
err = pthread_attr_getaffinity_np (&a, sizeof (c2), &c2);
if (err)
{
error (0, err, "pthread_attr_getaffinity_np failed");
result = 1;
}
else if (memcmp (&c1, &c2, sizeof (c1)))
{
error (0, 0, "pthread_attr_getaffinity_np returned different CPU mask than pthread_getattr_np");
result = 1;
}
}
err = pthread_attr_destroy (&a);
if (err)
{
error (0, err, "pthread_attr_destroy failed");
result = 1;
}
pthread_t th;
err = pthread_create (&th, NULL, tf, NULL);
if (err)
{
error (0, err, "pthread_create #1 failed");
result = 1;
}
else
{
void *ret;
err = pthread_join (th, &ret);
if (err)
{
error (0, err, "pthread_join #1 failed");
result = 1;
}
else if (ret != NULL)
result = 1;
}
err = pthread_attr_init (&a);
if (err)
{
error (0, err, "pthread_attr_init failed");
result = 1;
}
err = pthread_create (&th, &a, tf, &a);
if (err)
{
error (0, err, "pthread_create #2 failed");
result = 1;
}
else
{
void *ret;
err = pthread_join (th, &ret);
if (err)
{
error (0, err, "pthread_join #2 failed");
result = 1;
}
else if (ret != NULL)
result = 1;
}
err = pthread_attr_setguardsize (&a, 16 * sysconf (_SC_PAGESIZE));
if (err)
{
error (0, err, "pthread_attr_setguardsize failed");
result = 1;
}
err = pthread_create (&th, &a, tf, &a);
if (err)
{
error (0, err, "pthread_create #3 failed");
result = 1;
}
else
{
void *ret;
err = pthread_join (th, &ret);
if (err)
{
error (0, err, "pthread_join #3 failed");
result = 1;
}
else if (ret != NULL)
result = 1;
}
err = pthread_attr_destroy (&a);
if (err)
{
error (0, err, "pthread_attr_destroy failed");
result = 1;
}
return result;
}
void TPC_srv(void (*conn_init)(T_Connect *,T_NetHead *),void (*quit)(int),void (*poolchk)(void),int sizeof_gda)
{
int ret;
struct sockaddr_in sin,cin;
struct servent *sp;
char *p;
int s;
pthread_t pthread_id;
pthread_attr_t attr;
struct timeval tm;
fd_set efds;
socklen_t leng=1;
int sock=-1;
T_Connect Conn;
struct linger so_linger;
tzset();
ret= pthread_attr_init(&attr);
if(ret) {
ShowLog(1,"can not init pthread attr %s",strerror(ret));
return ;
}
//设置分离线程
ret=pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
if(ret) {
ShowLog(1,"can't set pthread attr:%s",strerror(ret));
return ;
}
//设置线程堆栈保护区 256K
ret=pthread_attr_setguardsize(&attr,(size_t)(1024 * 256));
SRVFUNC=Function;
signal(SIGPIPE,SIG_IGN);
signal(SIGHUP,SIG_IGN);
signal(SIGINT ,SIG_IGN);
signal(SIGPWR ,quit);
signal(SIGTERM,quit);
initconnect(&Conn);
Conn.family=family;
Conn.Var=0;
p=getenv("SERVICE");
if(!p || !*p) {
ShowLog(1,"缺少环境变量 SERVICE ,不知守候哪个端口！");
quit(3);
}
//测试端口是否被占用
sock=tcpopen("localhost",p);
if(sock>-1) {
ShowLog(1,"端口 %s 已经被占用",p);
close(sock);
sock=-1;
quit(255);
}
bzero(&sin,sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = INADDR_ANY;
if(isdigit(*p)){
sin.sin_port=htons((u_short)atoi(p));
} else {
if((sp=getservbyname(p,"tcp"))==NULL){
ShowLog(1,"getsrvbyname %s error",p);
quit(3);
}
sin.sin_port=(u_short)sp->s_port;
}
sock=socket(AF_INET,SOCK_STREAM,0);
if(sock < 0) {
ShowLog(1,"open socket error=%d,%s",errno,
strerror(errno));
quit(3);
}
bind(sock,(struct sockaddr *)&sin,sizeof(sin));
leng=1;
setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&leng,sizeof(leng));
//避免 TIME_WAIT
so_linger.l_onoff=1;
so_linger.l_linger=0;
ret=setsockopt(sock, SOL_SOCKET, SO_LINGER, &so_linger, sizeof so_linger);
if(ret) ShowLog(1,"set SO_LINGER err=%d,%s",errno,strerror(errno));
leng=sizeof(cin);
int repeat=0;
ShowLog(0,"work start!main sock=%d",sock);
p=getenv("TIMEOUT");
if(p && isdigit(*p)) {
Conn.timeout=60*atoi(p);
} else Conn.timeout=0;
p=getenv("SENDSIZE");
if(p && isdigit(*p)) {
Conn.MTU=atoi(p);
} else Conn.MTU=0;
//避免 TIME_WAIT
so_linger.l_onoff=1;
so_linger.l_linger=0;
ret=setsockopt(sock, SOL_SOCKET, SO_LINGER, &so_linger, sizeof so_linger);
if(ret) ShowLog(1,"set SO_LINGER err=%d,%s",errno,strerror(errno));
listen(sock,1000);// 以后用配置
while(1) {
do {
FD_ZERO(&efds);
FD_SET(sock, &efds);
//健康检查周期5分钟
tm.tv_sec=300;
tm.tv_usec=0;
ret=select(sock+1,&efds,NULL,&efds,&tm);
//ShowLog(4,"%s:aft select ret=%d,sock=%d",__FUNCTION__,ret,sock);
if(ret==-1) {
ShowLog(1,"select error %s",strerror(errno));
close(sock);
quit(3);
}
if(ret==0 && poolchk) poolchk();
} while(ret<=0);
s=accept(sock,(struct sockaddr *)&cin,&leng);
if(s<0) {
ShowLog(1,"%s:accept err=%d,%s",__FUNCTION__,errno,strerror(errno));
switch(errno) {
case EMFILE: //fd用完了,其他线程还要继续工作，主线程休息一下。
case ENFILE:
sleep(30);
continue;
default:break;
}
sleep(3);
if(++repeat < 20) continue;
ShowLog(1,"%s:network fail! err=%s",__FUNCTION__,strerror(errno));
close(sock);
quit(5);
}
Conn.Socket=s;
Conn.only_do=(int (*)())conn_init; //借用一下
Conn.SendLen=sizeof_gda;
ret=pthread_create(&pthread_id,&attr,thread_work,&Conn);
if(ret) {
ShowLog(1,"%s:pthread_create:%s",__FUNCTION__,strerror(ret));
close(s);
if(ret==EAGAIN||ret==ENOMEM) { //线程数用完了，休息一会，等一些线程退出
sleep(30);
}
continue;
}
while(Conn.Socket != -1) usleep(1000);
}
ret=pthread_attr_destroy(&attr);
close(sock);
quit(0);
}
void *POSIX_Init(
void *argument
)
{
int status;
int scope;
int inheritsched;
int schedpolicy;
size_t stacksize;
#if HAVE_DECL_PTHREAD_ATTR_SETGUARDSIZE
size_t guardsize;
#endif
void *stackaddr;
int detachstate;
struct sched_param schedparam;
pthread_attr_t attr;
pthread_attr_t destroyed_attr;
TEST_BEGIN();
/* set the time of day, and print our buffer in multiple ways */
set_time( TM_FRIDAY, TM_MAY, 24, 96, 11, 5, 0 );
/* get id of this thread */
Init_id = pthread_self();
printf( "Init's ID is 0x%08" PRIxpthread_t "\n", Init_id );
/* exercise init and destroy */
puts( "Init - pthread_attr_init - EINVAL (NULL attr)" );
status = pthread_attr_init( NULL );
fatal_directive_check_status_only( status, EINVAL, "null attribute" );
puts( "Init - pthread_attr_init - SUCCESSFUL" );
status = pthread_attr_init( &attr );
posix_service_failed( status, "pthread_attr_init" );
puts( "Init - initialize and destroy an attribute - SUCCESSFUL" );
status = pthread_attr_init( &destroyed_attr );
posix_service_failed( status, "pthread_attr_init");
status = pthread_attr_destroy( &destroyed_attr );
posix_service_failed( status, "pthread_attr_destroy");
puts( "Init - pthread_attr_destroy - EINVAL (NULL attr)" );
status = pthread_attr_destroy( NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL attribute" );
puts( "Init - pthread_attr_destroy - EINVAL (not initialized)" );
status = pthread_attr_destroy( &destroyed_attr );
fatal_directive_check_status_only( status, EINVAL, "not initialized" );
/* check some errors in pthread_create */
puts( "Init - pthread_create - EINVAL (attr not initialized)" );
status = pthread_create( &Task_id, &destroyed_attr, Task_1, NULL );
fatal_directive_check_status_only( status, EINVAL, "attribute not initialized" );
/* junk stack address */
status = pthread_attr_setstackaddr( &attr, (void *)&schedparam );
posix_service_failed( status, "setstackaddr");
/* must go around pthread_attr_setstacksize to set a bad stack size */
attr.stacksize = 0;
puts( "Init - pthread_create - EINVAL (stacksize too small)" );
status = pthread_create( &Task_id, &attr, Task_1, NULL );
fatal_directive_check_status_only( status, EINVAL, "stacksize too small" );
/* reset all the fields */
status = pthread_attr_init( &attr );
posix_service_failed( status, "pthread_attr_init");
#if HAVE_DECL_PTHREAD_ATTR_SETSTACKADDR
attr.stacksize = rtems_configuration_get_work_space_size() * 10;
puts( "Init - pthread_create - EAGAIN (stacksize too large)" );
status = pthread_create( &Task_id, &attr, Task_1, NULL );
fatal_directive_check_status_only( status, EAGAIN, "stacksize too large" );
#endif
status = pthread_attr_init( &attr );
posix_service_failed( status, "pthread_attr_init");
/* must go around pthread_attr_set routines to set a bad value */
attr.inheritsched = -1;
puts( "Init - pthread_create - EINVAL (invalid inherit scheduler)" );
status = pthread_create( &Task_id, &attr, Task_1, NULL );
fatal_directive_check_status_only( status, EINVAL, "invalid inherit scheduler" );
/* check out the error case for system scope not supported */
status = pthread_attr_init( &attr );
posix_service_failed( status, " pthread_attr_init");
/* must go around pthread_attr_set routines to set a bad value */
attr.contentionscope = PTHREAD_SCOPE_SYSTEM;
puts( "Init - pthread_create - ENOTSUP (unsupported system contention scope)" );
status = pthread_create( &Task_id, &attr, Task_1, NULL );
fatal_directive_check_status_only( status, ENOTSUP,
"unsupported system contention scope" );
status = pthread_attr_init( &attr );
posix_service_failed( status, "pthread_attr_init");
/* now check out pthread_create for inherit scheduler */
status = pthread_attr_setinheritsched( &attr, PTHREAD_INHERIT_SCHED );
posix_service_failed( status, "pthread_attr_setinheritsched");
puts( "Init - pthread_create - SUCCESSFUL (inherit scheduler)" );
status = pthread_create( &Task_id, &attr, Task_1, NULL );
posix_service_failed( status, "pthread_create");
status = pthread_join( Task_id, NULL );
posix_service_failed( status, " pthread_join");
/* switch to Task_1 */
/* exercise get and set scope */
empty_line();
status = pthread_attr_init( &attr );
posix_service_failed( status, "pthread_attr_init");
puts( "Init - pthread_attr_setscope - EINVAL (NULL attr)" );
status = pthread_attr_setscope( NULL, PTHREAD_SCOPE_PROCESS );
fatal_directive_check_status_only( status, EINVAL , "NULL attr" );
puts( "Init - pthread_attr_setscope - ENOTSUP" );
status = pthread_attr_setscope( &attr, PTHREAD_SCOPE_SYSTEM );
fatal_directive_check_status_only( status, ENOTSUP, "PTHREAD_SCOPE_SYSTEM" );
puts( "Init - pthread_attr_setscope - EINVAL (not initialized attr)" );
status = pthread_attr_setscope( &destroyed_attr, PTHREAD_SCOPE_PROCESS );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_setscope - EINVAL (invalid scope)" );
status = pthread_attr_setscope( &attr, -1 );
fatal_directive_check_status_only( status, EINVAL, "invalid scope" );
puts( "Init - pthread_attr_setscope - SUCCESSFUL" );
status = pthread_attr_setscope( &attr, PTHREAD_SCOPE_PROCESS );
posix_service_failed( status, "pthread_attr_setscope");
puts( "Init - pthread_attr_getscope - EINVAL (NULL attr)" );
status = pthread_attr_getscope( NULL, &scope );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_getscope - EINVAL (NULL scope)" );
status = pthread_attr_getscope( &attr, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL scope" );
puts( "Init - pthread_attr_getscope - EINVAL (not initialized attr)" );
status = pthread_attr_getscope( &destroyed_attr, &scope );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_getscope - SUCCESSFUL" );
status = pthread_attr_getscope( &attr, &scope );
posix_service_failed( status, "pthread_attr_getscope");
printf( "Init - current scope attribute = %d\n", scope );
/* exercise get and set inherit scheduler */
empty_line();
puts( "Init - pthread_attr_setinheritsched - EINVAL (NULL attr)" );
status = pthread_attr_setinheritsched( NULL, PTHREAD_INHERIT_SCHED );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_setinheritsched - EINVAL (not initialized attr)" );
status =
pthread_attr_setinheritsched( &destroyed_attr, PTHREAD_INHERIT_SCHED );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_setinheritsched - ENOTSUP (invalid inheritsched)" );
status = pthread_attr_setinheritsched( &attr, -1 );
fatal_directive_check_status_only( status, ENOTSUP, "invalid inheritsched" );
puts( "Init - pthread_attr_setinheritsched - SUCCESSFUL" );
status = pthread_attr_setinheritsched( &attr, PTHREAD_INHERIT_SCHED );
posix_service_failed( status, "pthread_attr_setinheritsched");
puts( "Init - pthread_attr_getinheritsched - EINVAL (NULL attr)" );
status = pthread_attr_getinheritsched( NULL, &inheritsched );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_getinheritsched - EINVAL (NULL inheritsched)" );
status = pthread_attr_getinheritsched( &attr, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL inheritsched" );
puts( "Init - pthread_attr_getinheritsched - EINVAL (not initialized attr)" );
status = pthread_attr_getinheritsched( &destroyed_attr, &inheritsched );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_getinheritsched - SUCCESSFUL" );
status = pthread_attr_getinheritsched( &attr, &inheritsched );
posix_service_failed( status, "pthread_attr_getinheritsched");
printf( "Init - current inherit scheduler attribute = %d\n", inheritsched );
/* exercise get and set inherit scheduler */
empty_line();
puts( "Init - pthread_attr_setschedpolicy - EINVAL (NULL attr)" );
status = pthread_attr_setschedpolicy( NULL, SCHED_FIFO );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_setschedpolicy - EINVAL (not initialized attr)" );
status =
pthread_attr_setschedpolicy( &destroyed_attr, SCHED_OTHER );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_setschedpolicy - ENOTSUP (invalid schedpolicy)" );
status = pthread_attr_setschedpolicy( &attr, -1 );
fatal_directive_check_status_only( status, ENOTSUP, "invalid schedpolicy" );
puts( "Init - pthread_attr_setschedpolicy - SUCCESSFUL" );
status = pthread_attr_setschedpolicy( &attr, SCHED_RR );
posix_service_failed( status, "pthread_attr_setschedpolicy");
puts( "Init - pthread_attr_getschedpolicy - EINVAL (NULL attr)" );
status = pthread_attr_getschedpolicy( NULL, &schedpolicy );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_getschedpolicy - EINVAL (NULL schedpolicy)" );
status = pthread_attr_getschedpolicy( &attr, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL schedpolicy" );
puts( "Init - pthread_attr_getschedpolicy - EINVAL (not initialized attr)" );
status = pthread_attr_getschedpolicy( &destroyed_attr, &schedpolicy );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_getschedpolicy - SUCCESSFUL" );
status = pthread_attr_getschedpolicy( &attr, &schedpolicy );
posix_service_failed( status, "pthread_attr_getschedpolicy");
printf( "Init - current scheduler policy attribute = %d\n", schedpolicy );
/* exercise get and set stack size */
empty_line();
puts( "Init - pthread_attr_setstacksize - EINVAL (NULL attr)" );
status = pthread_attr_setstacksize( NULL, 0 );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_setstacksize - EINVAL (not initialized attr)" );
status =
pthread_attr_setstacksize( &destroyed_attr, 0 );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_setstacksize - SUCCESSFUL (low stacksize)" );
status = pthread_attr_setstacksize( &attr, 0 );
posix_service_failed( status, "pthread_attr_setstacksize");
puts( "Init - pthread_attr_setstacksize - SUCCESSFUL (high stacksize)" );
status = pthread_attr_setstacksize( &attr, STACK_MINIMUM_SIZE * 2 );
posix_service_failed( status, "");
puts( "Init - pthread_attr_getstacksize - EINVAL (NULL attr)" );
status = pthread_attr_getstacksize( NULL, &stacksize );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_getstacksize - EINVAL (NULL stacksize)" );
status = pthread_attr_getstacksize( &attr, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL stacksize" );
puts( "Init - pthread_attr_getstacksize - EINVAL (not initialized attr)" );
status = pthread_attr_getstacksize( &destroyed_attr, &stacksize );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_getstacksize - SUCCESSFUL" );
status = pthread_attr_getstacksize( &attr, &stacksize );
posix_service_failed( status, "pthread_attr_getstacksize");
if ( stacksize == (STACK_MINIMUM_SIZE * 2) )
printf( "Init - current stack size attribute is OK\n" );
/* exercise get and set stack address */
empty_line();
puts( "Init - pthread_attr_setstackaddr - EINVAL (NULL attr)" );
status = pthread_attr_setstackaddr( NULL, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_setstackaddr - EINVAL (not initialized attr)" );
status = pthread_attr_setstackaddr( &destroyed_attr, NULL );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_setstackaddr - SUCCESSFUL" );
status = pthread_attr_setstackaddr( &attr, 0 );
posix_service_failed( status, "");
/* get stack addr */
puts( "Init - pthread_attr_getstackaddr - EINVAL (NULL attr)" );
status = pthread_attr_getstackaddr( NULL, &stackaddr );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_getstackaddr - EINVAL (NULL stackaddr)" );
status = pthread_attr_getstackaddr( &attr, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL stackaddr" );
puts( "Init - pthread_attr_getstackaddr - EINVAL (not initialized attr)" );
status = pthread_attr_getstackaddr( &destroyed_attr, &stackaddr );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_getstackaddr - SUCCESSFUL" );
status = pthread_attr_getstackaddr( &attr, &stackaddr );
posix_service_failed( status, "pthread_attr_getstackaddr");
printf( "Init - current stack address attribute = %p\n", stackaddr );
/* exercise get and set stack (as pair) */
empty_line();
#if HAVE_DECL_PTHREAD_ATTR_SETSTACK
puts( "Init - pthread_attr_setstack- EINVAL (NULL attr)" );
status = pthread_attr_setstack( NULL, &stackaddr, 1024 );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_setstack- EINVAL (destroyed attr)" );
status = pthread_attr_setstack( &destroyed_attr, &stackaddr, 1024 );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_setstack- SUCCESSFUL (< min stack)" );
status = pthread_attr_setstack( &attr, stackaddr, 0 );
posix_service_failed( status, "OK");
puts( "Init - pthread_attr_setstack- SUCCESSFUL (big stack)" );
status = pthread_attr_setstack( &attr, stackaddr, STACK_MINIMUM_SIZE * 2 );
posix_service_failed( status, "OK");
#endif
#if HAVE_DECL_PTHREAD_ATTR_GETSTACK
puts( "Init - pthread_attr_getstack- EINVAL (NULL attr)" );
status = pthread_attr_getstack( NULL, &stackaddr, &stacksize );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_getstack- EINVAL (destroyed attr)" );
status = pthread_attr_getstack( &destroyed_attr, &stackaddr, &stacksize );
fatal_directive_check_status_only( status, EINVAL, "&destroyed attr" );
puts( "Init - pthread_attr_getstack- EINVAL (NULL stack)" );
status = pthread_attr_getstack( &attr, NULL, &stacksize );
fatal_directive_check_status_only( status, EINVAL, "&NULL stack" );
puts( "Init - pthread_attr_getstack- EINVAL (NULL stacksize)" );
status = pthread_attr_getstack( &attr, &stackaddr, NULL );
fatal_directive_check_status_only( status, EINVAL, "&NULL size" );
puts( "Init - pthread_attr_getstack- SUCCESSFUL" );
status = pthread_attr_getstack( &attr, &stackaddr, &stacksize );
posix_service_failed( status, "pthread_attr_getstack");
#endif
/* exercise get and set detach state */
empty_line();
#if HAVE_DECL_PTHREAD_ATTR_SETGUARDSIZE
puts( "Init - pthread_attr_setguardsize - EINVAL (NULL attr)" );
status = pthread_attr_setguardsize( NULL, 0 );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_setguardsize - EINVAL (not initialized attr)" );
status = pthread_attr_setguardsize( &destroyed_attr, 0 );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_setguardsize - SUCCESSFUL (low guardsize)" );
status = pthread_attr_setguardsize( &attr, 0 );
posix_service_failed( status, "pthread_attr_setguardsize");
puts( "Init - pthread_attr_setguardsize - SUCCESSFUL (high guardsize)" );
status = pthread_attr_setguardsize( &attr, STACK_MINIMUM_SIZE * 2 );
posix_service_failed( status, "");
#endif
#if HAVE_DECL_PTHREAD_ATTR_GETGUARDSIZE
puts( "Init - pthread_attr_getguardsize - EINVAL (NULL attr)" );
status = pthread_attr_getguardsize( NULL, &guardsize );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_getguardsize - EINVAL (NULL guardsize)" );
status = pthread_attr_getguardsize( &attr, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL guardsize" );
puts( "Init - pthread_attr_getguardsize - EINVAL (not initialized attr)" );
status = pthread_attr_getguardsize( &destroyed_attr, &guardsize );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_getguardsize - SUCCESSFUL" );
status = pthread_attr_getguardsize( &attr, &guardsize );
posix_service_failed( status, "pthread_attr_getguardsize");
#endif
/* exercise get and set detach state */
empty_line();
puts( "Init - pthread_attr_setdetachstate - EINVAL (NULL attr)" );
status = pthread_attr_setdetachstate( NULL, PTHREAD_CREATE_DETACHED );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_setdetachstate - EINVAL (not initialized attr)" );
status =
pthread_attr_setdetachstate( &destroyed_attr, PTHREAD_CREATE_JOINABLE );
fatal_directive_check_status_only( status, EINVAL, "not initialized att" );
puts( "Init - pthread_attr_setdetachstate - EINVAL (invalid detachstate)" );
status = pthread_attr_setdetachstate( &attr, -1 );
fatal_directive_check_status_only( status, EINVAL, "invalid detachstate" );
puts( "Init - pthread_attr_setdetachstate - SUCCESSFUL" );
status = pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE );
posix_service_failed( status, "pthread_attr_setdetachstate");
puts( "Init - pthread_attr_getdetachstate - EINVAL (NULL attr)" );
status = pthread_attr_getdetachstate( NULL, &detachstate );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_getdetachstate - EINVAL (NULL detatchstate)" );
status = pthread_attr_getdetachstate( &attr, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL detatchstate" );
puts( "Init - pthread_attr_getdetachstate - EINVAL (not initialized attr)" );
status = pthread_attr_getdetachstate( &destroyed_attr, &detachstate );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_getdetachstate - SUCCESSFUL" );
status = pthread_attr_getdetachstate( &attr, &detachstate );
posix_service_failed( status, "pthread_attr_getdetachstate");
printf( "Init - current detach state attribute = %d\n", detachstate );
/* exercise get and set scheduling parameters */
empty_line();
puts( "Init - pthread_attr_getschedparam - SUCCESSFUL" );
status = pthread_attr_getschedparam( &attr, &schedparam );
posix_service_failed( status, "pthread_attr_getschedparam");
print_schedparam( "Init - ", &schedparam );
puts( "Init - pthread_attr_setschedparam - EINVAL (NULL attr)" );
status = pthread_attr_setschedparam( NULL, &schedparam );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_setschedparam - EINVAL (not initialized attr)" );
status = pthread_attr_setschedparam( &destroyed_attr, &schedparam );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_setschedparam - EINVAL (NULL schedparam)" );
status = pthread_attr_setschedparam( &attr, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL schedparam" );
puts( "Init - pthread_attr_setschedparam - SUCCESSFUL" );
status = pthread_attr_setschedparam( &attr, &schedparam );
posix_service_failed( status, "pthread_attr_setschedparam");
puts( "Init - pthread_attr_getschedparam - EINVAL (NULL attr)" );
status = pthread_attr_getschedparam( NULL, &schedparam );
fatal_directive_check_status_only( status, EINVAL, "pthread_attr_getschedparam" );
puts( "Init - pthread_attr_getschedparam - EINVAL (not initialized attr)" );
status = pthread_attr_getschedparam( &destroyed_attr, &schedparam );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_getschedparam - EINVAL (NULL schedparam)" );
status = pthread_attr_getschedparam( &attr, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL schedparam" );
/* exercise pthread_getschedparam */
empty_line();
puts( "Init - pthread_getschedparam - EINVAL (NULL policy)" );
status = pthread_getschedparam( pthread_self(), NULL, &schedparam );
fatal_directive_check_status_only( status, EINVAL, "NULL policy" );
puts( "Init - pthread_getschedparam - EINVAL (NULL schedparam)" );
status = pthread_getschedparam( pthread_self(), &schedpolicy, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL schedparam" );
puts( "Init - pthread_getschedparam - ESRCH (bad thread)" );
status = pthread_getschedparam( (pthread_t) -1, &schedpolicy, &schedparam );
fatal_directive_check_status_only( status, ESRCH, "bad thread" );
puts( "Init - pthread_getschedparam - SUCCESSFUL" );
status = pthread_getschedparam( pthread_self(), &schedpolicy, &schedparam );
posix_service_failed( status, "pthread_getschedparam");
printf( "Init - policy = %d\n", schedpolicy );
print_schedparam( "Init - ", &schedparam );
/* exercise pthread_setschedparam */
empty_line();
puts( "Init - pthread_setschedparam - EINVAL (NULL schedparam)" );
status = pthread_setschedparam( pthread_self(), SCHED_OTHER, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL schedparam" );
schedparam.sched_priority = -1;
puts( "Init - pthread_setschedparam - EINVAL (invalid priority)" );
status = pthread_setschedparam( pthread_self(), SCHED_OTHER, NULL );
fatal_directive_check_status_only( status, EINVAL, "invalid priority" );
/* reset sched_param */
status = pthread_getschedparam( pthread_self(), &schedpolicy, &schedparam );
posix_service_failed( status, "pthread_getschedparam");
puts( "Init - pthread_setschedparam - EINVAL (invalid policy)" );
status = pthread_setschedparam( pthread_self(), -1, &schedparam );
fatal_directive_check_status_only( status, EINVAL, "invalid policy" );
puts( "Init - pthread_setschedparam - ESRCH (invalid thread)" );
status = pthread_setschedparam( (pthread_t) -1, SCHED_OTHER, &schedparam );
fatal_directive_check_status_only( status, ESRCH, "invalid thread" );
/* now get sporadic server errors */
schedparam.sched_ss_repl_period.tv_sec = 0;
schedparam.sched_ss_repl_period.tv_nsec = 0;
schedparam.sched_ss_init_budget.tv_sec = 1;
schedparam.sched_ss_init_budget.tv_nsec = 1;
puts( "Init - pthread_setschedparam - EINVAL (replenish == 0)" );
status = pthread_setschedparam( pthread_self(), SCHED_SPORADIC, &schedparam );
fatal_directive_check_status_only( status, EINVAL, "replenish == 0" );
schedparam.sched_ss_repl_period.tv_sec = 1;
schedparam.sched_ss_repl_period.tv_nsec = 1;
schedparam.sched_ss_init_budget.tv_sec = 0;
schedparam.sched_ss_init_budget.tv_nsec = 0;
puts( "Init - pthread_setschedparam - EINVAL (budget == 0)" );
status = pthread_setschedparam( pthread_self(), SCHED_SPORADIC, &schedparam );
fatal_directive_check_status_only( status, EINVAL, "budget == 0" );
schedparam.sched_ss_repl_period.tv_sec = 1;
schedparam.sched_ss_repl_period.tv_nsec = 0;
schedparam.sched_ss_init_budget.tv_sec = 1;
schedparam.sched_ss_init_budget.tv_nsec = 1;
puts( "Init - pthread_setschedparam - EINVAL (replenish < budget)" );
status = pthread_setschedparam( pthread_self(), SCHED_SPORADIC, &schedparam );
fatal_directive_check_status_only( status, EINVAL, "replenish < budget" );
schedparam.sched_ss_repl_period.tv_sec = 2;
schedparam.sched_ss_repl_period.tv_nsec = 0;
schedparam.sched_ss_init_budget.tv_sec = 1;
schedparam.sched_ss_init_budget.tv_nsec = 0;
schedparam.sched_ss_low_priority = -1;
puts( "Init - pthread_setschedparam - EINVAL (invalid priority)" );
status = pthread_setschedparam( pthread_self(), SCHED_SPORADIC, &schedparam );
fatal_directive_check_status_only( status, EINVAL, "invalid priority" );
/*
* Create a sporadic thread that doesn't need it's priority
* boosted
*/
empty_line();
puts( "Init - pthread_attr_init - SUCCESSFUL" );
status = pthread_attr_init( &attr );
posix_service_failed( status, "pthread_attr_init" );
puts( "Init - pthread_attr_setinheritsched - EXPLICIT - SUCCESSFUL" );
status = pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
rtems_test_assert( !status );
schedparam.sched_ss_repl_period.tv_sec = 3;
schedparam.sched_ss_repl_period.tv_nsec = 3;
schedparam.sched_ss_init_budget.tv_sec = 1;
schedparam.sched_ss_init_budget.tv_nsec = 1;
schedparam.sched_priority = sched_get_priority_max( SCHED_FIFO );
schedparam.sched_ss_low_priority = sched_get_priority_max( SCHED_FIFO ) - 6;
puts( "Init - pthread_attr_setschedpolicy - SUCCESSFUL" );
status = pthread_attr_setschedpolicy( &attr, SCHED_SPORADIC );
posix_service_failed( status, "pthread_attr_setschedparam");
puts( "Init - pthread_attr_setschedparam - SUCCESSFUL" );
status = pthread_attr_setschedparam( &attr, &schedparam );
posix_service_failed( status, "pthread_attr_setschedparam");
status = pthread_create( &Task2_id, &attr, Task_2, NULL );
rtems_test_assert( !status );
status = pthread_join( Task2_id, NULL );
posix_service_failed( status, " pthread_join");
TEST_END();
rtems_test_exit( 0 );
return NULL; /* just so the compiler thinks we returned something */
}
static int my_pthread_attr_setguardsize(pthread_attr_t *__attr, size_t guard_size)
{
pthread_attr_t *realattr = (pthread_attr_t *) *(unsigned int *) __attr;
return pthread_attr_setguardsize(realattr, guard_size);
}
static int
do_test (void)
{
int result = 0;
char name[sizeof "/tst-mqueue6-" + sizeof (pid_t) * 3];
snprintf (name, sizeof (name), "/tst-mqueue6-%u", getpid ());
struct mq_attr attr = { .mq_maxmsg = 1, .mq_msgsize = 1 };
mqd_t q = mq_open (name, O_CREAT | O_EXCL | O_RDWR, 0600, &attr);
if (q == (mqd_t) -1)
{
printf ("mq_open failed with: %m\n");
return result;
}
else
add_temp_mq (name);
pthread_attr_t nattr;
if (pthread_attr_init (&nattr)
|| pthread_attr_setguardsize (&nattr, 0))
{
puts ("pthread_attr_t setup failed");
result = 1;
}
fct_guardsize = 1;
struct sigevent ev;
memset (&ev, 0xaa, sizeof (ev));
ev.sigev_notify = SIGEV_THREAD;
ev.sigev_notify_function = fct;
ev.sigev_notify_attributes = &nattr;
ev.sigev_value.sival_ptr = &q;
if (mq_notify (q, &ev) != 0)
{
printf ("mq_notify (q, { SIGEV_THREAD }) failed with: %m\n");
result = 1;
}
size_t ps = sysconf (_SC_PAGESIZE);
if (pthread_attr_setguardsize (&nattr, 32 * ps))
{
puts ("pthread_attr_t setup failed");
result = 1;
}
if (mq_notify (q, &ev) == 0)
{
puts ("second mq_notify (q, { SIGEV_NONE }) unexpectedly succeeded");
result = 1;
}
else if (errno != EBUSY)
{
printf ("second mq_notify (q, { SIGEV_NONE }) failed with: %m\n");
result = 1;
}
if (fct_cnt != 0)
{
printf ("fct called too early (%d on %d)\n", fct_cnt, __LINE__);
result = 1;
}
result |= mqsend (q);
result |= mqrecv (q);
result |= mqrecv (q);
if (fct_cnt != 1)
{
printf ("fct not called (%d on %d)\n", fct_cnt, __LINE__);
result = 1;
}
else if (fct_guardsize != 0)
{
printf ("fct_guardsize %zd != 0\n", fct_guardsize);
result = 1;
}
if (mq_notify (q, &ev) != 0)
{
printf ("third mq_notify (q, { SIGEV_NONE }) failed with: %m\n");
result = 1;
}
if (mq_notify (q, NULL) != 0)
{
printf ("mq_notify (q, NULL) failed with: %m\n");
result = 1;
}
memset (&ev, 0x11, sizeof (ev));
ev.sigev_notify = SIGEV_THREAD;
ev.sigev_notify_function = fct;
ev.sigev_notify_attributes = &nattr;
ev.sigev_value.sival_ptr = &q;
if (mq_notify (q, &ev) != 0)
{
printf ("mq_notify (q, { SIGEV_THREAD }) failed with: %m\n");
result = 1;
}
if (pthread_attr_setguardsize (&nattr, 0))
{
puts ("pthread_attr_t setup failed");
result = 1;
}
if (mq_notify (q, &ev) == 0)
{
puts ("second mq_notify (q, { SIGEV_NONE }) unexpectedly succeeded");
result = 1;
}
else if (errno != EBUSY)
{
printf ("second mq_notify (q, { SIGEV_NONE }) failed with: %m\n");
result = 1;
}
if (fct_cnt != 1)
{
printf ("fct called too early (%d on %d)\n", fct_cnt, __LINE__);
result = 1;
}
result |= mqsend (q);
result |= mqrecv (q);
result |= mqrecv (q);
if (fct_cnt != 2)
{
printf ("fct not called (%d on %d)\n", fct_cnt, __LINE__);
result = 1;
}
else if (fct_guardsize != 32 * ps)
{
printf ("fct_guardsize %zd != %zd\n", fct_guardsize, 32 * ps);
result = 1;
}
if (mq_notify (q, &ev) != 0)
{
printf ("third mq_notify (q, { SIGEV_NONE }) failed with: %m\n");
result = 1;
}
if (mq_notify (q, NULL) != 0)
{
printf ("mq_notify (q, NULL) failed with: %m\n");
result = 1;
}
if (pthread_attr_destroy (&nattr) != 0)
{
puts ("pthread_attr_destroy failed");
result = 1;
}
if (mq_unlink (name) != 0)
{
printf ("mq_unlink failed: %m\n");
result = 1;
}
if (mq_close (q) != 0)
{
printf ("mq_close failed: %m\n");
result = 1;
}
memset (&ev, 0x55, sizeof (ev));
ev.sigev_notify = SIGEV_THREAD;
ev.sigev_notify_function = fct;
ev.sigev_notify_attributes = NULL;
ev.sigev_value.sival_int = 0;
if (mq_notify (q, &ev) == 0)
{
puts ("mq_notify on closed mqd_t unexpectedly succeeded");
result = 1;
}
else if (errno != EBADF)
{
printf ("mq_notify on closed mqd_t did not fail with EBADF: %m\n");
result = 1;
}
if (fct_err)
result = 1;
return result;
}
static pthread_attr_t * /* Get thread attributes from command line */
get_thread_attributes_from_cl(int argc, char *argv[],
pthread_attr_t *attrp)
{
int s, opt, allocate_stack;
long stack_size, guard_size;
void *stack_addr;
pthread_attr_t *ret_attrp = NULL; /* Set to attrp if we initialize
a thread attributes object */
allocate_stack = 0;
stack_size = -1;
guard_size = -1;
while ((opt = getopt(argc, argv, "ag:s:")) != -1) {
switch (opt) {
case 'a': allocate_stack = 1; break;
case 'g': guard_size = strtoul(optarg, NULL, 0); break;
case 's': stack_size = strtoul(optarg, NULL, 0); break;
default: usage(argv[0], NULL);
}
}
if (allocate_stack && stack_size == -1)
usage(argv[0], "Specifying -a without -s makes no sense\n");
if (argc > optind)
usage(argv[0], "Extraneous command-line arguments\n");
if (stack_size >= 0 || guard_size > 0) {
ret_attrp = attrp;
s = pthread_attr_init(attrp);
if (s != 0)
handle_error_en(s, "pthread_attr_init");
}
if (stack_size >= 0) {
if (!allocate_stack) {
s = pthread_attr_setstacksize(attrp, stack_size);
if (s != 0)
handle_error_en(s, "pthread_attr_setstacksize");
} else {
s = posix_memalign(&stack_addr, sysconf(_SC_PAGESIZE),
stack_size);
if (s != 0)
handle_error_en(s, "posix_memalign");
printf("Allocated thread stack at %p\n\n", stack_addr);
s = pthread_attr_setstack(attrp, stack_addr, stack_size);
if (s != 0)
handle_error_en(s, "pthread_attr_setstacksize");
}
}
if (guard_size >= 0) {
s = pthread_attr_setguardsize(attrp, guard_size);
if (s != 0)
handle_error_en(s, "pthread_attr_setstacksize");
}
return ret_attrp;
}
/* This function will initialize every pthread_attr_t object in the scenarii array */
void scenar_init()
{
int ret=0;
int i;
int old;
long pagesize, minstacksize;
long tsa, tss, tps;
pagesize =sysconf(_SC_PAGESIZE);
minstacksize =sysconf(_SC_THREAD_STACK_MIN);
tsa =sysconf(_SC_THREAD_ATTR_STACKADDR);
tss =sysconf(_SC_THREAD_ATTR_STACKSIZE);
tps =sysconf(_SC_THREAD_PRIORITY_SCHEDULING);
#if VERBOSE > 0
output("System abilities:\n");
output(" TSA: %li\n", tsa);
output(" TSS: %li\n", tss);
output(" TPS: %li\n", tps);
output(" pagesize: %li\n", pagesize);
output(" min stack size: %li\n", minstacksize);
#endif
if (minstacksize % pagesize)
{
UNTESTED("The min stack size is not a multiple of the page size");
}
for (i=0; i<NSCENAR; i++)
{
#if VERBOSE > 2
output("Initializing attribute for scenario %i: %s\n", i, scenarii[i].descr);
#endif
ret = pthread_attr_init(&scenarii[i].ta);
if (ret != 0) { UNRESOLVED(ret, "Failed to initialize a thread attribute object"); }
/* Set the attributes according to the scenario */
if (scenarii[i].detached == 1)
{
ret = pthread_attr_setdetachstate(&scenarii[i].ta, PTHREAD_CREATE_DETACHED);
if (ret != 0) { UNRESOLVED(ret, "Unable to set detachstate"); }
}
else
{
ret = pthread_attr_getdetachstate(&scenarii[i].ta, &old);
if (ret != 0) { UNRESOLVED(ret, "Unable to get detachstate from initialized attribute"); }
if (old != PTHREAD_CREATE_JOINABLE) { FAILED("The default attribute is not PTHREAD_CREATE_JOINABLE"); }
}
#if VERBOSE > 4
output("Detach state was set sucessfully\n");
#endif
/* Sched related attributes */
if (tps>0) /* This routine is dependent on the Thread Execution Scheduling option */
{
if (scenarii[i].explicitsched == 1)
ret = pthread_attr_setinheritsched(&scenarii[i].ta, PTHREAD_EXPLICIT_SCHED);
else
ret = pthread_attr_setinheritsched(&scenarii[i].ta, PTHREAD_INHERIT_SCHED);
if (ret != 0) { UNRESOLVED(ret, "Unable to set inheritsched attribute"); }
#if VERBOSE > 4
output("inheritsched state was set sucessfully\n");
#endif
}
#if VERBOSE > 4
else
output("TPS unsupported => inheritsched parameter untouched\n");
#endif
if (tps>0) /* This routine is dependent on the Thread Execution Scheduling option */
{
if (scenarii[i].schedpolicy == 1)
{
ret = pthread_attr_setschedpolicy(&scenarii[i].ta, SCHED_FIFO);
}
if (scenarii[i].schedpolicy == 2)
{
ret = pthread_attr_setschedpolicy(&scenarii[i].ta, SCHED_RR);
}
if (ret != 0) { UNRESOLVED(ret, "Unable to set the sched policy"); }
#if VERBOSE > 4
if (scenarii[i].schedpolicy)
output("Sched policy was set sucessfully\n");
else
output("Sched policy untouched\n");
#endif
}
#if VERBOSE > 4
else
output("TPS unsupported => sched policy parameter untouched\n");
#endif
if (scenarii[i].schedparam != 0)
{
struct sched_param sp;
ret = pthread_attr_getschedpolicy(&scenarii[i].ta, &old);
if (ret != 0) { UNRESOLVED(ret, "Unable to get sched policy from attribute"); }
if (scenarii[i].schedparam == 1)
sp.sched_priority = sched_get_priority_max(old);
if (scenarii[i].schedparam == -1)
sp.sched_priority = sched_get_priority_min(old);
ret = pthread_attr_setschedparam(&scenarii[i].ta, &sp);
if (ret != 0) { UNRESOLVED(ret, "Failed to set the sched param"); }
#if VERBOSE > 4
output("Sched param was set sucessfully to %i\n", sp.sched_priority);
}
else
{
output("Sched param untouched\n");
#endif
}
if (tps>0) /* This routine is dependent on the Thread Execution Scheduling option */
{
ret = pthread_attr_getscope(&scenarii[i].ta, &old);
if (ret != 0) { UNRESOLVED(ret, "Failed to get contension scope from thread attribute"); }
if (scenarii[i].altscope != 0)
{
if (old == PTHREAD_SCOPE_PROCESS)
old = PTHREAD_SCOPE_SYSTEM;
else
old = PTHREAD_SCOPE_PROCESS;
ret = pthread_attr_setscope(&scenarii[i].ta, old);
//if (ret != 0) { UNRESOLVED(ret, "Failed to set contension scope"); }
#if VERBOSE > 0
if (ret != 0) { output("WARNING: The TPS option is claimed to be supported but setscope fails\n"); }
#endif
#if VERBOSE > 4
output("Contension scope set to %s\n", old==PTHREAD_SCOPE_PROCESS?"PTHREAD_SCOPE_PROCESS":"PTHREAD_SCOPE_SYSTEM");
}
else
{
output("Contension scope untouched (%s)\n", old==PTHREAD_SCOPE_PROCESS?"PTHREAD_SCOPE_PROCESS":"PTHREAD_SCOPE_SYSTEM");
#endif
}
}
#if VERBOSE > 4
else
output("TPS unsupported => sched contension scope parameter untouched\n");
#endif
/* Stack related attributes */
if ((tss>0) && (tsa>0)) /* This routine is dependent on the Thread Stack Address Attribute
and Thread Stack Size Attribute options */
{
if (scenarii[i].altstack != 0)
{
/* This is slightly more complicated. We need to alloc a new stack
and free it upon test termination */
/* We will alloc with a simulated guardsize of 1 pagesize */
scenarii[i].bottom = malloc(minstacksize + pagesize);
if (scenarii[i].bottom == NULL) { UNRESOLVED(errno,"Unable to alloc enough memory for alternative stack"); }
ret = pthread_attr_setstack(&scenarii[i].ta, scenarii[i].bottom, minstacksize);
if (ret != 0) { UNRESOLVED(ret, "Failed to specify alternate stack"); }
#if VERBOSE > 1
output("Alternate stack created successfully. Bottom=%p, Size=%i\n", scenarii[i].bottom, minstacksize);
#endif
}
}
#if VERBOSE > 4
else
output("TSA or TSS unsupported => No alternative stack\n");
#endif
#ifndef WITHOUT_XOPEN
if (scenarii[i].guard != 0)
{
if (scenarii[i].guard == 1)
ret = pthread_attr_setguardsize(&scenarii[i].ta, 0);
if (scenarii[i].guard == 2)
ret = pthread_attr_setguardsize(&scenarii[i].ta, pagesize);
if (ret != 0) { UNRESOLVED(ret, "Unable to set guard area size in thread stack"); }
#if VERBOSE > 4
output("Guard size set to %i\n", (scenarii[i].guard==1)?1:pagesize);
#endif
}
#endif
if (tss>0) /* This routine is dependent on the Thread Stack Size Attribute option */
{
if (scenarii[i].altsize != 0)
{
ret = pthread_attr_setstacksize(&scenarii[i].ta, minstacksize);
if (ret != 0) { UNRESOLVED(ret, "Unable to change stack size"); }
#if VERBOSE > 4
output("Stack size set to %i (this is the min)\n", minstacksize);
#endif
}
}
#if VERBOSE > 4
else
output("TSS unsupported => stack size unchanged\n");
#endif
ret = sem_init(&scenarii[i].sem, 0,0);
if (ret == -1) { UNRESOLVED(errno, "Unable to init a semaphore"); }
}
#if VERBOSE > 0
output("All %i thread attribute objects were initialized\n\n", NSCENAR);
#endif
}
static int
do_test (void)
{
int result = 0;
pthread_attr_t a;
cpu_set_t c1, c2;
int err = pthread_attr_init (&a);
if (err)
{
error (0, err, "pthread_attr_init failed");
result = 1;
}
err = pthread_attr_getaffinity_np (&a, sizeof (c1), &c1);
if (err && err != ENOSYS)
{
error (0, err, "pthread_attr_getaffinity_np failed");
result = 1;
}
err = pthread_attr_destroy (&a);
if (err)
{
error (0, err, "pthread_attr_destroy failed");
result = 1;
}
err = pthread_getattr_np (pthread_self (), &a);
if (err)
{
error (0, err, "pthread_getattr_np failed");
result = 1;
}
int detachstate;
err = pthread_attr_getdetachstate (&a, &detachstate);
if (err)
{
error (0, err, "pthread_attr_getdetachstate failed");
result = 1;
}
else if (detachstate != PTHREAD_CREATE_JOINABLE)
{
error (0, 0, "initial thread not joinable");
result = 1;
}
void *stackaddr;
size_t stacksize;
err = pthread_attr_getstack (&a, &stackaddr, &stacksize);
if (err)
{
error (0, err, "pthread_attr_getstack failed");
result = 1;
}
else if ((void *) &a < stackaddr
|| (void *) &a >= stackaddr + stacksize)
{
error (0, 0, "pthread_attr_getstack returned range does not cover main's stack");
result = 1;
}
else
printf ("initial thread stack %p-%p (0x%zx)\n", stackaddr,
stackaddr + stacksize, stacksize);
size_t guardsize;
err = pthread_attr_getguardsize (&a, &guardsize);
if (err)
{
error (0, err, "pthread_attr_getguardsize failed");
result = 1;
}
else if (guardsize != 0)
{
error (0, 0, "pthread_attr_getguardsize returned %zd != 0",
guardsize);
result = 1;
}
int scope;
err = pthread_attr_getscope (&a, &scope);
if (err)
{
error (0, err, "pthread_attr_getscope failed");
result = 1;
}
else if (scope != PTHREAD_SCOPE_SYSTEM)
{
error (0, 0, "pthread_attr_getscope returned %d != PTHREAD_SCOPE_SYSTEM",
scope);
result = 1;
}
int inheritsched;
err = pthread_attr_getinheritsched (&a, &inheritsched);
if (err)
{
error (0, err, "pthread_attr_getinheritsched failed");
result = 1;
}
else if (inheritsched != PTHREAD_INHERIT_SCHED)
{
error (0, 0, "pthread_attr_getinheritsched returned %d != PTHREAD_INHERIT_SCHED",
inheritsched);
result = 1;
}
err = pthread_getaffinity_np (pthread_self (), sizeof (c1), &c1);
if (err == 0)
{
err = pthread_attr_getaffinity_np (&a, sizeof (c2), &c2);
if (err)
{
error (0, err, "pthread_attr_getaffinity_np failed");
result = 1;
}
else if (memcmp (&c1, &c2, sizeof (c1)))
{
error (0, 0, "pthread_attr_getaffinity_np returned different CPU mask than pthread_getattr_np");
result = 1;
}
}
err = pthread_attr_destroy (&a);
if (err)
{
error (0, err, "pthread_attr_destroy failed");
result = 1;
}
pthread_t th;
err = pthread_create (&th, NULL, tf, NULL);
if (err)
{
error (0, err, "pthread_create #1 failed");
result = 1;
}
else
{
void *ret;
err = pthread_join (th, &ret);
if (err)
{
error (0, err, "pthread_join #1 failed");
result = 1;
}
else if (ret != NULL)
result = 1;
}
err = pthread_attr_init (&a);
if (err)
{
error (0, err, "pthread_attr_init failed");
result = 1;
}
DIAG_PUSH_NEEDS_COMMENT;
#if __GNUC_PREREQ (7, 0)
/* GCC 8 warns about aliasing of the restrict-qualified arguments
passed &a. Since pthread_create does not dereference its fourth
argument, this aliasing, which is deliberate in this test, cannot
in fact cause problems. */
DIAG_IGNORE_NEEDS_COMMENT (8, "-Wrestrict");
#endif
err = pthread_create (&th, &a, tf, &a);
DIAG_POP_NEEDS_COMMENT;
if (err)
{
error (0, err, "pthread_create #2 failed");
result = 1;
}
else
{
void *ret;
err = pthread_join (th, &ret);
if (err)
{
error (0, err, "pthread_join #2 failed");
result = 1;
}
else if (ret != NULL)
result = 1;
}
err = pthread_attr_setguardsize (&a, 16 * sysconf (_SC_PAGESIZE));
if (err)
{
error (0, err, "pthread_attr_setguardsize failed");
result = 1;
}
DIAG_PUSH_NEEDS_COMMENT;
#if __GNUC_PREREQ (7, 0)
/* GCC 8 warns about aliasing of the restrict-qualified arguments
passed &a. Since pthread_create does not dereference its fourth
argument, this aliasing, which is deliberate in this test, cannot
in fact cause problems. */
DIAG_IGNORE_NEEDS_COMMENT (8, "-Wrestrict");
#endif
err = pthread_create (&th, &a, tf, &a);
DIAG_POP_NEEDS_COMMENT;
if (err)
{
error (0, err, "pthread_create #3 failed");
result = 1;
}
else
{
void *ret;
err = pthread_join (th, &ret);
if (err)
{
error (0, err, "pthread_join #3 failed");
result = 1;
}
else if (ret != NULL)
result = 1;
}
err = pthread_attr_destroy (&a);
if (err)
{
error (0, err, "pthread_attr_destroy failed");
result = 1;
}
return result;
}
