talexander
/
freebsd_amp_hwpstate
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
freebsd_amp_hwpstate/lib/libpthread/sys/lock.h

96 lines
3.7 KiB
C
Raw Normal View History

Add FIFO queueing locking operations based on atomic swap. Modify thread errno for the new libpthread changes. Reviewed by: davidxu
2003-04-18 05:02:39 +00:00
/*
Sorry folks; I accidentally committed a patch from what I was working on a couple of days ago. This should be the most recent changes. Noticed by: davidxu
2003-04-18 07:09:43 +00:00
* Copyright (c) 2001, 2003 Daniel Eischen <deischen@freebsd.org>.
Add FIFO queueing locking operations based on atomic swap. Modify thread errno for the new libpthread changes. Reviewed by: davidxu
2003-04-18 05:02:39 +00:00
* All rights reserved.
*
* 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 AUTHORS 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 AUTHOR 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.
*
* $FreeBSD$
*/
#ifndef _LOCK_H_
#define _LOCK_H_
struct lockreq;
struct lockuser;
struct lock;
enum lock_type {
LCK_DEFAULT = 0x0000, /* default is FIFO spin locks */
LCK_PRIORITY = 0x0001,
LCK_ADAPTIVE = 0x0002 /* call user-supplied handlers */
};
typedef void lock_handler_t(struct lock *, struct lockuser *);
struct lock {
struct lockreq *l_head;
struct lockreq *l_tail; /* only used for priority locks */
enum lock_type l_type;
lock_handler_t *l_wait; /* only used for adaptive locks */
lock_handler_t *l_wakeup; /* only used for adaptive locks */
};
/* Try to make this >= CACHELINESIZE */
struct lockreq {
struct lockuser *lr_watcher; /* only used for priority locks */
struct lockuser *lr_owner; /* only used for priority locks */
Don't assume sizeof(long) = sizeof(int) on x86; use int instead of long types for low-level locks. Add prototypes for some internal libc functions that are wrapped by the library as cancellation points. Add memory barriers to alpha atomic swap functions (submitted by davidxu). Requested by: bde
2003-09-03 17:56:26 +00:00
volatile int lr_locked; /* lock granted = 0, busy otherwise */
Add a method of yielding the current thread with the scheduler lock held (_thr_sched_switch_unlocked()) and use this to avoid dropping the scheduler lock and having the scheduler retake the same lock again. Add a better way of detecting if a low-level lock is in use. When switching out a thread due to blocking in the UTS, don't switch to the KSE's scheduler stack only to switch back to another thread. If possible switch to the new thread directly from the old thread and avoid the overhead of the extra context switch. Check for pending signals on a thread when entering the scheduler and add them to the threads signal frame. This includes some other minor signal fixes. Most of this was a joint effor between davidxu and myself. Reviewed by: davidxu Approved by: re@ (blanket for libpthread)
2003-05-16 19:58:30 +00:00
volatile int lr_active; /* non-zero if the lock is last lock for thread */
Add FIFO queueing locking operations based on atomic swap. Modify thread errno for the new libpthread changes. Reviewed by: davidxu
2003-04-18 05:02:39 +00:00
};
struct lockuser {
struct lockreq *lu_myreq; /* request to give up/trade */
struct lockreq *lu_watchreq; /* watch this request */
int lu_priority; /* only used for priority locks */
void *lu_private1; /* private{1,2} are initialized to */
void *lu_private2; /* NULL and can be used by caller */
#define lu_private lu_private1
};
#define _LCK_INITIALIZER(lck_req) { &lck_req, NULL, LCK_DEFAULT, \
NULL, NULL }
#define _LCK_REQUEST_INITIALIZER { 0, NULL, NULL, 0 }
#define _LCK_BUSY(lu) ((lu)->lu_watchreq->lr_locked != 0)
Add a method of yielding the current thread with the scheduler lock held (_thr_sched_switch_unlocked()) and use this to avoid dropping the scheduler lock and having the scheduler retake the same lock again. Add a better way of detecting if a low-level lock is in use. When switching out a thread due to blocking in the UTS, don't switch to the KSE's scheduler stack only to switch back to another thread. If possible switch to the new thread directly from the old thread and avoid the overhead of the extra context switch. Check for pending signals on a thread when entering the scheduler and add them to the threads signal frame. This includes some other minor signal fixes. Most of this was a joint effor between davidxu and myself. Reviewed by: davidxu Approved by: re@ (blanket for libpthread)
2003-05-16 19:58:30 +00:00
#define _LCK_ACTIVE(lu) ((lu)->lu_watchreq->lr_active != 0)
Change low-level locking a bit so that we can tell if a lock is being waitied on. Fix a races in join and cancellation. When trying to wait on a CV and the library is not yet threaded, make it threaded so that waiting actually works. When trying to nanosleep() and we're not threaded, just call the system call nanosleep instead of adding the thread to the wait queue. Clean up adding/removing new threads to the "all threads queue", assigning them unique ids, and tracking how many active threads there are. Do it all when the thread is added to the scheduling queue instead of making pthread_create() know how to do it. Fix a race where a thread could be marked for signal delivery but it could be exited before we actually add the signal to it. Other minor cleanups and bug fixes. Submitted by: davidxu Approved by: re@ (blanket for libpthread)
2003-05-24 02:29:25 +00:00
#define _LCK_GRANTED(lu) ((lu)->lu_watchreq->lr_locked == 3)
Add FIFO queueing locking operations based on atomic swap. Modify thread errno for the new libpthread changes. Reviewed by: davidxu
2003-04-18 05:02:39 +00:00
#define _LCK_SET_PRIVATE(lu, p) (lu)->lu_private = (void *)(p)
#define _LCK_GET_PRIVATE(lu) (lu)->lu_private
#define _LCK_SET_PRIVATE2(lu, p) (lu)->lu_private2 = (void *)(p)
#define _LCK_GET_PRIVATE2(lu) (lu)->lu_private2
Add the ability to reinitialize libpthread's internal FIFO-queueing locks. Reviewed by: davidxu
2003-11-04 20:01:38 +00:00
void _lock_acquire(struct lock *, struct lockuser *, int);
Add FIFO queueing locking operations based on atomic swap. Modify thread errno for the new libpthread changes. Reviewed by: davidxu
2003-04-18 05:02:39 +00:00
void _lock_destroy(struct lock *);
Add the ability to reinitialize libpthread's internal FIFO-queueing locks. Reviewed by: davidxu
2003-11-04 20:01:38 +00:00
void _lock_grant(struct lock *, struct lockuser *);
Add FIFO queueing locking operations based on atomic swap. Modify thread errno for the new libpthread changes. Reviewed by: davidxu
2003-04-18 05:02:39 +00:00
int _lock_init(struct lock *, enum lock_type,
lock_handler_t *, lock_handler_t *);
Add the ability to reinitialize libpthread's internal FIFO-queueing locks. Reviewed by: davidxu
2003-11-04 20:01:38 +00:00
int _lock_reinit(struct lock *, enum lock_type,
lock_handler_t *, lock_handler_t *);
void _lock_release(struct lock *, struct lockuser *);
Add FIFO queueing locking operations based on atomic swap. Modify thread errno for the new libpthread changes. Reviewed by: davidxu
2003-04-18 05:02:39 +00:00
int _lockuser_init(struct lockuser *lu, void *priv);
void _lockuser_destroy(struct lockuser *lu);
Add the ability to reinitialize libpthread's internal FIFO-queueing locks. Reviewed by: davidxu
2003-11-04 20:01:38 +00:00
int _lockuser_reinit(struct lockuser *lu, void *priv);
Add a method of yielding the current thread with the scheduler lock held (_thr_sched_switch_unlocked()) and use this to avoid dropping the scheduler lock and having the scheduler retake the same lock again. Add a better way of detecting if a low-level lock is in use. When switching out a thread due to blocking in the UTS, don't switch to the KSE's scheduler stack only to switch back to another thread. If possible switch to the new thread directly from the old thread and avoid the overhead of the extra context switch. Check for pending signals on a thread when entering the scheduler and add them to the threads signal frame. This includes some other minor signal fixes. Most of this was a joint effor between davidxu and myself. Reviewed by: davidxu Approved by: re@ (blanket for libpthread)
2003-05-16 19:58:30 +00:00
void _lockuser_setactive(struct lockuser *lu, int active);
Add FIFO queueing locking operations based on atomic swap. Modify thread errno for the new libpthread changes. Reviewed by: davidxu
2003-04-18 05:02:39 +00:00
#endif