Skip to content
Projects
Groups
Snippets
Help
This project
Loading...
Sign in / Register
Toggle navigation
R
riscv-gcc-1
Overview
Overview
Details
Activity
Cycle Analytics
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Charts
Issues
0
Issues
0
List
Board
Labels
Milestones
Merge Requests
0
Merge Requests
0
CI / CD
CI / CD
Pipelines
Jobs
Schedules
Charts
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Charts
Create a new issue
Jobs
Commits
Issue Boards
Open sidebar
lvzhengyang
riscv-gcc-1
Commits
537cff9c
Commit
537cff9c
authored
Apr 07, 1999
by
Tom Tromey
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
Initial revision
From-SVN: r26256
parent
090aab56
Hide whitespace changes
Inline
Side-by-side
Showing
1 changed file
with
172 additions
and
0 deletions
+172
-0
boehm-gc/solaris_pthreads.c
+172
-0
No files found.
boehm-gc/solaris_pthreads.c
0 → 100644
View file @
537cff9c
/*
* Copyright (c) 1994 by Xerox Corporation. All rights reserved.
*
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
*
* Permission is hereby granted to use or copy this program
* for any purpose, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*/
/*
* Support code for Solaris threads. Provides functionality we wish Sun
* had provided. Relies on some information we probably shouldn't rely on.
* Modified Peter C. for Solaris Posix Threads.
*/
/* Boehm, September 14, 1994 4:44 pm PDT */
/* $Id: solaris_pthreads.c,v 1.1 1999/04/07 14:56:06 tromey Exp $ */
# if defined(_SOLARIS_PTHREADS)
# include "gc_priv.h"
# include <pthread.h>
# include <thread.h>
# include <signal.h>
# include <fcntl.h>
# include <sys/types.h>
# include <sys/mman.h>
# include <sys/time.h>
# include <sys/resource.h>
# include <sys/stat.h>
# include <sys/syscall.h>
# include <sys/procfs.h>
# include <sys/lwp.h>
# include <sys/reg.h>
# define _CLASSIC_XOPEN_TYPES
# include <unistd.h>
# include <errno.h>
# include "solaris_threads.h"
# include <stdio.h>
#undef pthread_join
#undef pthread_create
pthread_cond_t
GC_prom_join_cv
;
/* Broadcast when any thread terminates */
pthread_cond_t
GC_create_cv
;
/* Signalled when a new undetached */
/* thread starts. */
extern
bool
GC_multithreaded
;
/* We use the allocation lock to protect thread-related data structures. */
/* We stop the world using /proc primitives. This makes some */
/* minimal assumptions about the threads implementation. */
/* We don't play by the rules, since the rules make this */
/* impossible (as of Solaris 2.3). Also note that as of */
/* Solaris 2.3 the various thread and lwp suspension */
/* primitives failed to stop threads by the time the request */
/* is completed. */
int
GC_pthread_join
(
pthread_t
wait_for
,
void
**
status
)
{
return
GC_thr_join
((
thread_t
)
wait_for
,
NULL
,
status
);
}
int
GC_pthread_create
(
pthread_t
*
new_thread
,
const
pthread_attr_t
*
attr_in
,
void
*
(
*
thread_execp
)(
void
*
),
void
*
arg
)
{
int
result
;
GC_thread
t
;
pthread_t
my_new_thread
;
pthread_attr_t
attr
;
word
my_flags
=
0
;
int
flag
;
void
*
stack
;
size_t
stack_size
;
int
n
;
struct
sched_param
schedparam
;
(
void
)
pthread_attr_getstacksize
(
attr_in
,
&
stack_size
);
(
void
)
pthread_attr_getstackaddr
(
attr_in
,
&
stack
);
(
void
)
pthread_attr_init
(
&
attr
);
LOCK
();
if
(
!
GC_thr_initialized
)
{
GC_thr_init
();
}
GC_multithreaded
++
;
if
(
stack
==
0
)
{
if
(
stack_size
==
0
)
stack_size
=
GC_min_stack_sz
;
else
stack_size
+=
thr_min_stack
();
stack
=
(
void
*
)
GC_stack_alloc
(
&
stack_size
);
if
(
stack
==
0
)
{
GC_multithreaded
--
;
UNLOCK
();
errno
=
ENOMEM
;
return
-
1
;
}
}
else
{
my_flags
|=
CLIENT_OWNS_STACK
;
}
(
void
)
pthread_attr_setstacksize
(
&
attr
,
stack_size
);
(
void
)
pthread_attr_setstackaddr
(
&
attr
,
stack
);
(
void
)
pthread_attr_getscope
(
attr_in
,
&
n
);
(
void
)
pthread_attr_setscope
(
&
attr
,
n
);
(
void
)
pthread_attr_getschedparam
(
attr_in
,
&
schedparam
);
(
void
)
pthread_attr_setschedparam
(
&
attr
,
&
schedparam
);
(
void
)
pthread_attr_getschedpolicy
(
attr_in
,
&
n
);
(
void
)
pthread_attr_setschedpolicy
(
&
attr
,
n
);
(
void
)
pthread_attr_getinheritsched
(
attr_in
,
&
n
);
(
void
)
pthread_attr_setinheritsched
(
&
attr
,
n
);
(
void
)
pthread_attr_getdetachstate
(
attr_in
,
&
flag
);
if
(
flag
==
PTHREAD_CREATE_DETACHED
)
{
my_flags
|=
DETACHED
;
}
(
void
)
pthread_attr_setdetachstate
(
&
attr
,
PTHREAD_CREATE_JOINABLE
);
/*
* thr_create can call malloc(), which if redirected will
* attempt to acquire the allocation lock.
* Unlock here to prevent deadlock.
*/
#if 0
#ifdef I386
UNLOCK();
#endif
#endif
result
=
pthread_create
(
&
my_new_thread
,
&
attr
,
thread_execp
,
arg
);
#if 0
#ifdef I386
LOCK();
#endif
#endif
if
(
result
==
0
)
{
t
=
GC_new_thread
(
my_new_thread
);
t
->
flags
=
my_flags
;
if
(
!
(
my_flags
&
DETACHED
))
cond_init
(
&
(
t
->
join_cv
),
USYNC_THREAD
,
0
);
t
->
stack
=
stack
;
t
->
stack_size
=
stack_size
;
if
(
new_thread
!=
0
)
*
new_thread
=
my_new_thread
;
pthread_cond_signal
(
&
GC_create_cv
);
}
else
{
if
(
!
(
my_flags
&
CLIENT_OWNS_STACK
))
{
GC_stack_free
(
stack
,
stack_size
);
}
GC_multithreaded
--
;
}
UNLOCK
();
pthread_attr_destroy
(
&
attr
);
return
(
result
);
}
# else
#ifndef LINT
int
GC_no_sunOS_pthreads
;
#endif
# endif
/* SOLARIS_THREADS */
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment