538 lines
11 KiB
C
538 lines
11 KiB
C
/* $NetBSD: pthread_attr.c,v 1.19 2020/01/29 13:47:31 kamil Exp $ */
|
|
|
|
/*-
|
|
* Copyright (c) 2001, 2002, 2003, 2008 The NetBSD Foundation, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to The NetBSD Foundation
|
|
* by Nathan J. Williams.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
|
|
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
|
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__RCSID("$NetBSD: pthread_attr.c,v 1.19 2020/01/29 13:47:31 kamil Exp $");
|
|
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#ifndef __lint__
|
|
#define pthread_attr_get_np _pthread_attr_get_np
|
|
#endif
|
|
|
|
#include "pthread.h"
|
|
#include "pthread_int.h"
|
|
|
|
__weak_alias(pthread_attr_get_np, _pthread_attr_get_np)
|
|
|
|
static struct pthread_attr_private *pthread__attr_init_private(
|
|
pthread_attr_t *);
|
|
|
|
static struct pthread_attr_private *
|
|
pthread__attr_init_private(pthread_attr_t *attr)
|
|
{
|
|
struct pthread_attr_private *p;
|
|
|
|
if ((p = attr->pta_private) != NULL)
|
|
return p;
|
|
|
|
p = calloc(1, sizeof(*p));
|
|
if (p != NULL) {
|
|
attr->pta_private = p;
|
|
p->ptap_policy = SCHED_OTHER;
|
|
p->ptap_stacksize = pthread__stacksize;
|
|
p->ptap_guardsize = pthread__guardsize;
|
|
}
|
|
return p;
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_init(pthread_attr_t *attr)
|
|
{
|
|
|
|
attr->pta_magic = PT_ATTR_MAGIC;
|
|
attr->pta_flags = 0;
|
|
attr->pta_private = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_destroy(pthread_attr_t *attr)
|
|
{
|
|
struct pthread_attr_private *p;
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
if ((p = attr->pta_private) != NULL)
|
|
free(p);
|
|
|
|
attr->pta_magic = PT_ATTR_DEAD;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_get_np(pthread_t thread, pthread_attr_t *attr)
|
|
{
|
|
struct pthread_attr_private *p;
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
p = pthread__attr_init_private(attr);
|
|
if (p == NULL)
|
|
return ENOMEM;
|
|
|
|
attr->pta_flags = thread->pt_flags &
|
|
(PT_FLAG_DETACHED | PT_FLAG_SCOPE_SYSTEM | PT_FLAG_EXPLICIT_SCHED);
|
|
|
|
p->ptap_namearg = thread->pt_name;
|
|
p->ptap_stackaddr = thread->pt_stack.ss_sp;
|
|
p->ptap_stacksize = thread->pt_stack.ss_size;
|
|
p->ptap_guardsize = thread->pt_guardsize;
|
|
return pthread_getschedparam(thread, &p->ptap_policy, &p->ptap_sp);
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate)
|
|
{
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
if (attr->pta_flags & PT_FLAG_DETACHED)
|
|
*detachstate = PTHREAD_CREATE_DETACHED;
|
|
else
|
|
*detachstate = PTHREAD_CREATE_JOINABLE;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)
|
|
{
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
switch (detachstate) {
|
|
case PTHREAD_CREATE_JOINABLE:
|
|
attr->pta_flags &= ~PT_FLAG_DETACHED;
|
|
break;
|
|
case PTHREAD_CREATE_DETACHED:
|
|
attr->pta_flags |= PT_FLAG_DETACHED;
|
|
break;
|
|
default:
|
|
return EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_getguardsize(const pthread_attr_t *attr, size_t *guard)
|
|
{
|
|
struct pthread_attr_private *p;
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
if ((p = attr->pta_private) == NULL)
|
|
*guard = pthread__guardsize;
|
|
else
|
|
*guard = p->ptap_guardsize;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_setguardsize(pthread_attr_t *attr, size_t guard)
|
|
{
|
|
struct pthread_attr_private *p;
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
p = pthread__attr_init_private(attr);
|
|
if (p == NULL)
|
|
return ENOMEM;
|
|
|
|
p->ptap_guardsize = guard;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inherit)
|
|
{
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
if (attr->pta_flags & PT_FLAG_EXPLICIT_SCHED)
|
|
*inherit = PTHREAD_EXPLICIT_SCHED;
|
|
else
|
|
*inherit = PTHREAD_INHERIT_SCHED;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_setinheritsched(pthread_attr_t *attr, int inherit)
|
|
{
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
switch (inherit) {
|
|
case PTHREAD_INHERIT_SCHED:
|
|
attr->pta_flags &= ~PT_FLAG_EXPLICIT_SCHED;
|
|
break;
|
|
case PTHREAD_EXPLICIT_SCHED:
|
|
attr->pta_flags |= PT_FLAG_EXPLICIT_SCHED;
|
|
break;
|
|
default:
|
|
return EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_getscope(const pthread_attr_t *attr, int *scope)
|
|
{
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
if (attr->pta_flags & PT_FLAG_SCOPE_SYSTEM)
|
|
*scope = PTHREAD_SCOPE_SYSTEM;
|
|
else
|
|
*scope = PTHREAD_SCOPE_PROCESS;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_setscope(pthread_attr_t *attr, int scope)
|
|
{
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
switch (scope) {
|
|
case PTHREAD_SCOPE_PROCESS:
|
|
attr->pta_flags &= ~PT_FLAG_SCOPE_SYSTEM;
|
|
break;
|
|
case PTHREAD_SCOPE_SYSTEM:
|
|
attr->pta_flags |= PT_FLAG_SCOPE_SYSTEM;
|
|
break;
|
|
default:
|
|
return EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_setschedparam(pthread_attr_t *attr,
|
|
const struct sched_param *param)
|
|
{
|
|
struct pthread_attr_private *p;
|
|
int error;
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
if (param == NULL)
|
|
return EINVAL;
|
|
p = pthread__attr_init_private(attr);
|
|
if (p == NULL)
|
|
return ENOMEM;
|
|
error = pthread__checkpri(param->sched_priority);
|
|
if (error == 0)
|
|
p->ptap_sp = *param;
|
|
return error;
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_getschedparam(const pthread_attr_t *attr,
|
|
struct sched_param *param)
|
|
{
|
|
struct pthread_attr_private *p;
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
if (param == NULL)
|
|
return EINVAL;
|
|
p = attr->pta_private;
|
|
if (p == NULL)
|
|
memset(param, 0, sizeof(*param));
|
|
else
|
|
*param = p->ptap_sp;
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy)
|
|
{
|
|
struct pthread_attr_private *p;
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
switch (policy) {
|
|
case SCHED_OTHER:
|
|
case SCHED_FIFO:
|
|
case SCHED_RR:
|
|
p = pthread__attr_init_private(attr);
|
|
if (p == NULL)
|
|
return ENOMEM;
|
|
p->ptap_policy = policy;
|
|
return 0;
|
|
default:
|
|
return ENOTSUP;
|
|
}
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy)
|
|
{
|
|
struct pthread_attr_private *p;
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
p = attr->pta_private;
|
|
if (p == NULL) {
|
|
*policy = SCHED_OTHER;
|
|
return 0;
|
|
}
|
|
*policy = p->ptap_policy;
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_getstack(const pthread_attr_t *attr, void **addr, size_t *size)
|
|
{
|
|
struct pthread_attr_private *p;
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
if ((p = attr->pta_private) == NULL) {
|
|
*addr = NULL;
|
|
*size = pthread__stacksize;
|
|
} else {
|
|
*addr = p->ptap_stackaddr;
|
|
*size = p->ptap_stacksize;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_setstack(pthread_attr_t *attr, void *addr, size_t size)
|
|
{
|
|
struct pthread_attr_private *p;
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
p = pthread__attr_init_private(attr);
|
|
if (p == NULL)
|
|
return ENOMEM;
|
|
|
|
p->ptap_stackaddr = addr;
|
|
p->ptap_stacksize = size;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *size)
|
|
{
|
|
struct pthread_attr_private *p;
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
if ((p = attr->pta_private) == NULL)
|
|
*size = pthread__stacksize;
|
|
else
|
|
*size = p->ptap_stacksize;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_setstacksize(pthread_attr_t *attr, size_t size)
|
|
{
|
|
struct pthread_attr_private *p;
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
if (size < (size_t)sysconf(_SC_THREAD_STACK_MIN))
|
|
return EINVAL;
|
|
|
|
p = pthread__attr_init_private(attr);
|
|
if (p == NULL)
|
|
return ENOMEM;
|
|
|
|
p->ptap_stacksize = size;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_getstackaddr(const pthread_attr_t *attr, void **addr)
|
|
{
|
|
struct pthread_attr_private *p;
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
if ((p = attr->pta_private) == NULL)
|
|
*addr = NULL;
|
|
else
|
|
*addr = p->ptap_stackaddr;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_setstackaddr(pthread_attr_t *attr, void *addr)
|
|
{
|
|
struct pthread_attr_private *p;
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
p = pthread__attr_init_private(attr);
|
|
if (p == NULL)
|
|
return ENOMEM;
|
|
|
|
p->ptap_stackaddr = addr;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_getname_np(const pthread_attr_t *attr, char *name, size_t len,
|
|
void **argp)
|
|
{
|
|
struct pthread_attr_private *p;
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
if ((p = attr->pta_private) == NULL) {
|
|
name[0] = '\0';
|
|
if (argp != NULL)
|
|
*argp = NULL;
|
|
} else {
|
|
strlcpy(name, p->ptap_name, len);
|
|
if (argp != NULL)
|
|
*argp = p->ptap_namearg;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
pthread_attr_setname_np(pthread_attr_t *attr, const char *name, void *arg)
|
|
{
|
|
struct pthread_attr_private *p;
|
|
int namelen;
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
p = pthread__attr_init_private(attr);
|
|
if (p == NULL)
|
|
return ENOMEM;
|
|
|
|
namelen = snprintf(p->ptap_name, PTHREAD_MAX_NAMELEN_NP, name, arg);
|
|
if (namelen >= PTHREAD_MAX_NAMELEN_NP) {
|
|
p->ptap_name[0] = '\0';
|
|
return EINVAL;
|
|
}
|
|
p->ptap_namearg = arg;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
pthread_attr_setcreatesuspend_np(pthread_attr_t *attr)
|
|
{
|
|
|
|
pthread__error(EINVAL, "Invalid attribute",
|
|
attr->pta_magic == PT_ATTR_MAGIC);
|
|
|
|
attr->pta_flags |= PT_FLAG_SUSPENDED;
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
pthread_getattr_np(pthread_t thread, pthread_attr_t *attr)
|
|
{
|
|
int error;
|
|
|
|
if ((error = pthread_attr_init(attr)) != 0)
|
|
return error;
|
|
if ((error = pthread_attr_get_np(thread, attr)) != 0) {
|
|
(void)pthread_attr_destroy(attr);
|
|
return error;
|
|
}
|
|
return 0;
|
|
}
|