lib/libthread_xu/thread/thr_mutexattr.c

   1 /*
   2  * Copyright (c) 1996 Jeffrey Hsu <hsu@freebsd.org>.
   3  * Copyright (c) 1997 John Birrell <jb@cimlogic.com.au>.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. All advertising materials mentioning features or use of this software
  15  *    must display the following acknowledgement:
  16  *      This product includes software developed by John Birrell.
  17  * 4. Neither the name of the author nor the names of any co-contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  * $DragonFly: src/lib/libthread_xu/thread/thr_mutexattr.c,v 1.5 2006/04/06 13:03:09 davidxu Exp $
  34  */
  35
  36 #include "namespace.h"
  37 #include <string.h>
  38 #include <stdlib.h>
  39 #include <errno.h>
  40 #include <pthread.h>
  41 #include <pthread_np.h>
  42 #include "un-namespace.h"
  43
  44 #include "thr_private.h"
  45
  46 /* Default mutex attributes. */
  47 struct pthread_mutex_attr _pthread_mutexattr_default = {
  48         .m_type = PTHREAD_MUTEX_DEFAULT,
  49         .m_protocol = PTHREAD_PRIO_NONE,
  50         .m_ceiling = 0,
  51         .m_flags = 0
  52 };
  53
  54 int
  55 _pthread_mutexattr_init(pthread_mutexattr_t *attr)
  56 {
  57         int ret;
  58         pthread_mutexattr_t pattr;
  59
  60         if ((pattr = (pthread_mutexattr_t)
  61             malloc(sizeof(struct pthread_mutex_attr))) == NULL) {
  62                 ret = ENOMEM;
  63         } else {
  64                 memcpy(pattr, &_pthread_mutexattr_default,
  65                     sizeof(struct pthread_mutex_attr));
  66                 *attr = pattr;
  67                 ret = 0;
  68         }
  69         return (ret);
  70 }
  71
  72 int
  73 _pthread_mutexattr_setkind_np(pthread_mutexattr_t *attr, int kind)
  74 {
  75         int     ret;
  76         if (attr == NULL || *attr == NULL) {
  77                 errno = EINVAL;
  78                 ret = -1;
  79         } else {
  80                 (*attr)->m_type = kind;
  81                 ret = 0;
  82         }
  83         return(ret);
  84 }
  85
  86 int
  87 _pthread_mutexattr_getkind_np(pthread_mutexattr_t attr)
  88 {
  89         int     ret;
  90         if (attr == NULL) {
  91                 errno = EINVAL;
  92                 ret = -1;
  93         } else {
  94                 ret = attr->m_type;
  95         }
  96         return(ret);
  97 }
  98
  99 int
 100 _pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type)
 101 {
 102         int     ret;
 103         if (attr == NULL || *attr == NULL || type >= MUTEX_TYPE_MAX) {
 104                 errno = EINVAL;
 105                 ret = -1;
 106         } else {
 107                 (*attr)->m_type = type;
 108                 ret = 0;
 109         }
 110         return(ret);
 111 }
 112
 113 int
 114 _pthread_mutexattr_gettype(pthread_mutexattr_t *attr, int *type)
 115 {
 116         int     ret;
 117
 118         if (attr == NULL || *attr == NULL || (*attr)->m_type >=
 119             MUTEX_TYPE_MAX) {
 120                 ret = EINVAL;
 121         } else {
 122                 *type = (*attr)->m_type;
 123                 ret = 0;
 124         }
 125         return ret;
 126 }
 127
 128 int
 129 _pthread_mutexattr_destroy(pthread_mutexattr_t *attr)
 130 {
 131         int     ret;
 132         if (attr == NULL || *attr == NULL) {
 133                 ret = EINVAL;
 134         } else {
 135                 free(*attr);
 136                 *attr = NULL;
 137                 ret = 0;
 138         }
 139         return(ret);
 140 }
 141
 142 int
 143 _pthread_mutexattr_getpshared(const pthread_mutexattr_t *attr,
 144         int *pshared)
 145 {
 146
 147         if (attr == NULL || *attr == NULL)
 148                 return (EINVAL);
 149
 150         *pshared = PTHREAD_PROCESS_PRIVATE;
 151         return (0);
 152 }
 153
 154 int
 155 _pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared)
 156 {
 157
 158         if (attr == NULL || *attr == NULL)
 159                 return (EINVAL);
 160
 161         /* Only PTHREAD_PROCESS_PRIVATE is supported. */
 162         if (pshared != PTHREAD_PROCESS_PRIVATE)
 163                 return (EINVAL);
 164
 165         return (0);
 166 }
 167
 168 __strong_reference(_pthread_mutexattr_init, pthread_mutexattr_init);
 169 __strong_reference(_pthread_mutexattr_setkind_np, pthread_mutexattr_setkind_np);
 170 __strong_reference(_pthread_mutexattr_getkind_np, pthread_mutexattr_getkind_np);
 171 __strong_reference(_pthread_mutexattr_gettype, pthread_mutexattr_gettype);
 172 __strong_reference(_pthread_mutexattr_settype, pthread_mutexattr_settype);
 173 __strong_reference(_pthread_mutexattr_destroy, pthread_mutexattr_destroy);