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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [uClibc/] [libpthread/] [pthread.c] - Blame information for rev 1771

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1325 phoenix
/* vi: set sw=4 ts=4: */
2
/*
3
 * A _very_ simple clone based pthread-like implementation
4
 *
5
 * Copyright (C) 2001,2002 by Erik Andersen <andersee@debian.org>
6
 *
7
 * This program is free software; you can redistribute it and/or modify it
8
 * under the terms of the GNU Library General Public License as published by
9
 * the Free Software Foundation; either version 2 of the License, or (at your
10
 * option) any later version.
11
 *
12
 * This program is distributed in the hope that it will be useful, but WITHOUT
13
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License
15
 * for more details.
16
 *
17
 * You should have received a copy of the GNU Library General Public License
18
 * along with this program; if not, write to the Free Software Foundation,
19
 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20
 */
21
 
22
#include <stdlib.h>
23
#include <sched.h>
24
#include <signal.h>
25
#include <errno.h>
26
#include <unistd.h>
27
#include <pthread.h>
28
 
29
#define STACKSIZE 8096
30
 
31
#define CSIGNAL         0x000000ff      /* signal mask to be sent at exit */
32
#define CLONE_VM        0x00000100      /* set if VM shared between processes */
33
#define CLONE_FS        0x00000200      /* set if fs info shared between proces ses */
34
#define CLONE_FILES     0x00000400      /* set if open files shared between pro cesses */
35
#define CLONE_SIGHAND   0x00000800      /* set if signal handlers shared */
36
 
37
 
38
 
39
/* Lame home-grown clone based threading */
40
int pthread_mutex_init (pthread_mutex_t *mutex, const pthread_mutexattr_t *mutex_attr)
41
{
42
    mutex->__m_lock.__spinlock = 1;
43
        return 0;
44
}
45
 
46
int pthread_mutex_lock (pthread_mutex_t *mutex)
47
{
48
        while (mutex->__m_lock.__spinlock == 0) {
49
                usleep(10000);
50
        }
51
        --(mutex->__m_lock.__spinlock);
52
        return 0;
53
}
54
 
55
int pthread_mutex_unlock (pthread_mutex_t *mutex)
56
{
57
    ++(mutex->__m_lock.__spinlock);
58
        return 0;
59
}
60
 
61
int pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex)
62
{
63
        ++(mutex->__m_lock.__spinlock);
64
        while (cond->__c_lock.__spinlock == 0) {
65
                usleep(10000);
66
        }
67
        --(cond->__c_lock.__spinlock);
68
        return 0;
69
}
70
 
71
int pthread_cond_signal(pthread_cond_t *cond)
72
{
73
    ++(cond->__c_lock.__spinlock);
74
        return 0;
75
}
76
 
77
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *cond_attr)
78
{
79
    cond->__c_lock.__spinlock = 1;
80
        return 0;
81
}
82
 
83
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void* (*fn)(void *), void *data)
84
{
85
        long retval;
86
        void **newstack;
87
        int (*clonefunc)(void *) = (int (*)(void *))(fn);
88
 
89
        newstack = (void **) malloc(STACKSIZE);
90
        if (!newstack)
91
                return -1;
92
        newstack = (void **) (STACKSIZE + (char *) newstack);
93
        *--newstack = data;
94
        retval = clone(clonefunc, newstack,
95
                        CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | SIGCHLD, data);
96
        if (retval < 0) {
97
                errno = -retval;
98
                *thread = 0;
99
                retval = -1;
100
        } else {
101
                *thread = retval;
102
                retval = 0;
103
        }
104
        return retval;
105
}
106
 
107
int pthread_join (pthread_t thread, void **thread_return)
108
{
109
        int retval;
110
        /* Fixme -- wait for thread and get its return value */
111
        retval = EXIT_SUCCESS;
112
        if (thread_return)
113
                (int)*thread_return = retval;
114
        _exit(retval);
115
}
116
link_warning(pthread_join, "pthread_join is a stub and does not behave properly");
117
 
118
void pthread_exit (void *retval)
119
{
120
        _exit(*(int *)retval);
121
}

powered by: WebSVN 2.1.0

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