OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [newlib-1.18.0/] [newlib/] [libc/] [sys/] [linux/] [linuxthreads/] [specific.c] - Blame information for rev 829

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 207 jeremybenn
/* Linuxthreads - a simple clone()-based implementation of Posix        */
2
/* threads for Linux.                                                   */
3
/* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr)              */
4
/*                                                                      */
5
/* This program is free software; you can redistribute it and/or        */
6
/* modify it under the terms of the GNU Library General Public License  */
7
/* as published by the Free Software Foundation; either version 2       */
8
/* of the License, or (at your option) any later version.               */
9
/*                                                                      */
10
/* This program is distributed in the hope that it will be useful,      */
11
/* but WITHOUT ANY WARRANTY; without even the implied warranty of       */
12
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        */
13
/* GNU Library General Public License for more details.                 */
14
 
15
/* Thread-specific data */
16
 
17
#include <errno.h>
18
#include <stddef.h>
19
#include <stdlib.h>
20
#include "pthread.h"
21
#include "internals.h"
22
#include "spinlock.h"
23
#include "restart.h"
24
#include <bits/libc-lock.h>
25
 
26
 
27
/* Table of keys. */
28
 
29
static struct pthread_key_struct pthread_keys[PTHREAD_KEYS_MAX] =
30
  { { 0, NULL } };
31
 
32
/* For debugging purposes put the maximum number of keys in a variable.  */
33
const int __linuxthreads_pthread_keys_max = PTHREAD_KEYS_MAX;
34
const int __linuxthreads_pthread_key_2ndlevel_size = PTHREAD_KEY_2NDLEVEL_SIZE;
35
 
36
/* Mutex to protect access to pthread_keys */
37
 
38
static pthread_mutex_t pthread_keys_mutex = PTHREAD_MUTEX_INITIALIZER;
39
 
40
/* Create a new key */
41
 
42
int __pthread_key_create(pthread_key_t * key, destr_function destr)
43
{
44
  int i;
45
 
46
  pthread_mutex_lock(&pthread_keys_mutex);
47
  for (i = 0; i < PTHREAD_KEYS_MAX; i++) {
48
    if (! pthread_keys[i].in_use) {
49
      /* Mark key in use */
50
      pthread_keys[i].in_use = 1;
51
      pthread_keys[i].destr = destr;
52
      pthread_mutex_unlock(&pthread_keys_mutex);
53
      *key = i;
54
      return 0;
55
    }
56
  }
57
  pthread_mutex_unlock(&pthread_keys_mutex);
58
  return EAGAIN;
59
}
60
strong_alias (__pthread_key_create, pthread_key_create)
61
 
62
/* Reset deleted key's value to NULL in each live thread.
63
 * NOTE: this executes in the context of the thread manager! */
64
 
65
struct pthread_key_delete_helper_args {
66
  /* Damn, we need lexical closures in C! ;) */
67
  unsigned int idx1st, idx2nd;
68
  pthread_descr self;
69
};
70
 
71
static void pthread_key_delete_helper(void *arg, pthread_descr th)
72
{
73
  struct pthread_key_delete_helper_args *args = arg;
74
  unsigned int idx1st = args->idx1st;
75
  unsigned int idx2nd = args->idx2nd;
76
  pthread_descr self = args->self;
77
 
78
  if (self == 0)
79
    self = args->self = thread_self();
80
 
81
  if (!th->p_terminated) {
82
    /* pthread_exit() may try to free th->p_specific[idx1st] concurrently. */
83
    __pthread_lock(THREAD_GETMEM(th, p_lock), self);
84
    if (th->p_specific[idx1st] != NULL)
85
      th->p_specific[idx1st][idx2nd] = NULL;
86
    __pthread_unlock(THREAD_GETMEM(th, p_lock));
87
  }
88
}
89
 
90
/* Delete a key */
91
int pthread_key_delete(pthread_key_t key)
92
{
93
  pthread_descr self = thread_self();
94
 
95
  pthread_mutex_lock(&pthread_keys_mutex);
96
  if (key >= PTHREAD_KEYS_MAX || !pthread_keys[key].in_use) {
97
    pthread_mutex_unlock(&pthread_keys_mutex);
98
    return EINVAL;
99
  }
100
  pthread_keys[key].in_use = 0;
101
  pthread_keys[key].destr = NULL;
102
 
103
  /* Set the value of the key to NULL in all running threads, so
104
     that if the key is reallocated later by pthread_key_create, its
105
     associated values will be NULL in all threads.
106
 
107
     Do nothing if no threads have been created yet.  */
108
 
109
  if (__pthread_manager_request != -1)
110
    {
111
      struct pthread_key_delete_helper_args args;
112
      struct pthread_request request;
113
 
114
      args.idx1st = key / PTHREAD_KEY_2NDLEVEL_SIZE;
115
      args.idx2nd = key % PTHREAD_KEY_2NDLEVEL_SIZE;
116
      args.self = 0;
117
 
118
      request.req_thread = self;
119
      request.req_kind = REQ_FOR_EACH_THREAD;
120
      request.req_args.for_each.arg = &args;
121
      request.req_args.for_each.fn = pthread_key_delete_helper;
122
 
123
      TEMP_FAILURE_RETRY(__libc_write(__pthread_manager_request,
124
                                      (char *) &request, sizeof(request)));
125
      suspend(self);
126
    }
127
 
128
  pthread_mutex_unlock(&pthread_keys_mutex);
129
  return 0;
130
}
131
 
132
/* Set the value of a key */
133
 
134
int __pthread_setspecific(pthread_key_t key, const void * pointer)
135
{
136
  pthread_descr self = thread_self();
137
  unsigned int idx1st, idx2nd;
138
 
139
  if (key >= PTHREAD_KEYS_MAX || !pthread_keys[key].in_use)
140
    return EINVAL;
141
  idx1st = key / PTHREAD_KEY_2NDLEVEL_SIZE;
142
  idx2nd = key % PTHREAD_KEY_2NDLEVEL_SIZE;
143
  if (THREAD_GETMEM_NC(self, p_specific[idx1st]) == NULL) {
144
    void *newp = calloc(PTHREAD_KEY_2NDLEVEL_SIZE, sizeof (void *));
145
    if (newp == NULL)
146
      return ENOMEM;
147
    THREAD_SETMEM_NC(self, p_specific[idx1st], newp);
148
  }
149
  THREAD_GETMEM_NC(self, p_specific[idx1st])[idx2nd] = (void *) pointer;
150
  return 0;
151
}
152
strong_alias (__pthread_setspecific, pthread_setspecific)
153
 
154
/* Get the value of a key */
155
 
156
void * __pthread_getspecific(pthread_key_t key)
157
{
158
  pthread_descr self = thread_self();
159
  unsigned int idx1st, idx2nd;
160
 
161
  if (key >= PTHREAD_KEYS_MAX)
162
    return NULL;
163
  idx1st = key / PTHREAD_KEY_2NDLEVEL_SIZE;
164
  idx2nd = key % PTHREAD_KEY_2NDLEVEL_SIZE;
165
  if (THREAD_GETMEM_NC(self, p_specific[idx1st]) == NULL
166
      || !pthread_keys[key].in_use)
167
    return NULL;
168
  return THREAD_GETMEM_NC(self, p_specific[idx1st])[idx2nd];
169
}
170
strong_alias (__pthread_getspecific, pthread_getspecific)
171
 
172
/* Call the destruction routines on all keys */
173
 
174
void __pthread_destroy_specifics()
175
{
176
  pthread_descr self = thread_self();
177
  int i, j, round, found_nonzero;
178
  destr_function destr;
179
  void * data;
180
 
181
  for (round = 0, found_nonzero = 1;
182
       found_nonzero && round < PTHREAD_DESTRUCTOR_ITERATIONS;
183
       round++) {
184
    found_nonzero = 0;
185
    for (i = 0; i < PTHREAD_KEY_1STLEVEL_SIZE; i++)
186
      if (THREAD_GETMEM_NC(self, p_specific[i]) != NULL)
187
        for (j = 0; j < PTHREAD_KEY_2NDLEVEL_SIZE; j++) {
188
          destr = pthread_keys[i * PTHREAD_KEY_2NDLEVEL_SIZE + j].destr;
189
          data = THREAD_GETMEM_NC(self, p_specific[i])[j];
190
          if (destr != NULL && data != NULL) {
191
            THREAD_GETMEM_NC(self, p_specific[i])[j] = NULL;
192
            destr(data);
193
            found_nonzero = 1;
194
          }
195
        }
196
  }
197
  __pthread_lock(THREAD_GETMEM(self, p_lock), self);
198
  for (i = 0; i < PTHREAD_KEY_1STLEVEL_SIZE; i++) {
199
    if (THREAD_GETMEM_NC(self, p_specific[i]) != NULL) {
200
      free(THREAD_GETMEM_NC(self, p_specific[i]));
201
      THREAD_SETMEM_NC(self, p_specific[i], NULL);
202
    }
203
  }
204
  __pthread_unlock(THREAD_GETMEM(self, p_lock));
205
}
206
 
207
/* Thread-specific data for libc. */
208
 
209
static int
210
libc_internal_tsd_set(enum __libc_tsd_key_t key, const void * pointer)
211
{
212
  pthread_descr self = thread_self();
213
 
214
  THREAD_SETMEM_NC(self, p_libc_specific[key], (void *) pointer);
215
  return 0;
216
}
217
int (*__libc_internal_tsd_set)(enum __libc_tsd_key_t key, const void * pointer)
218
     = libc_internal_tsd_set;
219
 
220
static void *
221
libc_internal_tsd_get(enum __libc_tsd_key_t key)
222
{
223
  pthread_descr self = thread_self();
224
 
225
  return THREAD_GETMEM_NC(self, p_libc_specific[key]);
226
}
227
void * (*__libc_internal_tsd_get)(enum __libc_tsd_key_t key)
228
     = libc_internal_tsd_get;

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.