void check_all_locks(void)
{
unsigned int i;
check_lock(&shm->reaper_lock);
check_lock(&shm->syscalltable_lock);
for_each_child(i)
check_lock(&shm->children[i]->syscall.lock);
}
/* returns TRUE if something is awry */
bool check_all_locks(void)
{
unsigned int i;
bool ret = FALSE;
check_lock(&shm->syscalltable_lock);
for_each_child(i)
ret |= check_lock(&shm->children[i]->syscall.lock);
return ret;
}
void _spin_lock(spinlock_t *lock)
{
check_lock(&lock->debug);
while ( unlikely(!_raw_spin_trylock(&lock->raw)) )
while ( likely(_raw_spin_is_locked(&lock->raw)) )
cpu_relax();
}
void _write_lock_irq(rwlock_t *lock)
{
ASSERT(local_irq_is_enabled());
local_irq_disable();
check_lock(&lock->debug);
_raw_write_lock(&lock->raw);
}
bool
ttylock::lock()
{
int old_mask, pid;
bool ret = true;
if(get_names(tty) < 0)
return false;
old_mask = umask(0);
pid = getpid();
if (write_lock(pid_name, pid) < 0) {
umask(old_mask);
return false;
}
umask(old_mask);
if (link(pid_name.toLatin1(), dev_name.toLatin1()) < 0) {
if ((ret = check_lock(dev_name, getpid())) >= 0)
goto quit;
}
quit:
if(!ret)
unlink(dev_name.toLatin1());
unlink(pid_name.toLatin1());
locked = ret;
return ret;
}
void lock(lock_t *_lock)
{
pid_t pid = getpid();
while (_lock->lock != UNLOCKED) {
if (_lock->owner == pid) {
debugf("lol, already have lock!\n");
show_backtrace();
panic(EXIT_LOCKING_CATASTROPHE);
_exit(EXIT_FAILURE);
}
/* This is pretty horrible. But if we call lock()
* from stuck_syscall_info(), and a child is hogging a lock
* (or worse, a dead child), we'll deadlock, because main won't
* ever get back, and subsequently check_lock().
* So we add an extra explicit check here.
*/
if (pid == mainpid) {
check_lock(_lock);
} else {
/* Ok, we're a child pid.
* if something bad happened, like main crashed,
* we don't want to spin forever, so just get out.
*/
if ((shm->exit_reason != STILL_RUNNING) &&
(shm->exit_reason != EXIT_REACHED_COUNT)) {
_exit(EXIT_FAILURE);
}
}
usleep(1);
}
__lock(_lock);
}
static enum ach_status
rdlock( ach_channel_t *chan, int wait, const struct timespec *abstime ) {
ach_header_t *shm = chan->shm;
{
enum ach_status r = chan_lock(chan);
if( ACH_OK != r ) return r;
}
enum ach_status r = ACH_BUG;
while(ACH_BUG == r) {
if( chan->cancel ) { /* check operation cancelled */
pthread_mutex_unlock( &shm->sync.mutex );
r = ACH_CANCELED;
} else if( !wait ) r = ACH_OK; /* check no wait */
else if ( chan->seq_num != shm->last_seq ) r = ACH_OK; /* check if got a frame */
/* else condition wait */
else {
int i = abstime ?
pthread_cond_timedwait( &shm->sync.cond, &shm->sync.mutex, abstime ) :
pthread_cond_wait( &shm->sync.cond, &shm->sync.mutex );
enum ach_status c = check_lock(i, chan, 1);
if( ACH_OK != c ) r = c;
/* check r and condition next iteration */
}
}
return r;
}
unsigned long _write_lock_irqsave(rwlock_t *lock)
{
unsigned long flags;
local_irq_save(flags);
check_lock(&lock->debug);
_raw_write_lock(&lock->raw);
return flags;
}
void
ttylock::unlock()
{
locked = 0;
if(get_names(tty) < 0)
return;
if (check_lock(dev_name, 0) == 0)
unlink(dev_name.toLatin1());
}
void lock_leave(lock_t *lock)
{
if (!lock->init) return;
check_lock();
//bool dbg = (strcmp(lock->name, "&waterfall_hw_lock") == 0);
bool dbg = false;
lock->leave++;
if (dbg) printf("LOCK t%d %s RELEASE %s\n", TaskID(), TaskName(), lock->name);
}
void lock_enter(lock_t *lock)
{
if (!lock->init) return;
check_lock();
int token = lock->enter++;
//bool dbg = (strcmp(lock->name, "&waterfall_hw_lock") == 0);
bool dbg = false;
bool waiting = false;
while (token > lock->leave) {
if (dbg && !waiting) {
printf("LOCK t%d %s WAIT %s\n", TaskID(), TaskName(), lock->name);
waiting = true;
}
NextTaskL("lock enter");
check_lock();
}
if (dbg) printf("LOCK t%d %s ACQUIRE %s\n", TaskID(), TaskName(), lock->name);
}
/**
* generic acl checking for different methods (basic set of methods supported)
* returns null if no err
*/
static dav_error *check_methods(request_rec *r, const dav_resource *resource,
davacl_dir_cfg *conf)
{
const dav_hooks_repository *repos = REPOS(conf);
if (repos == NULL || resource == NULL)
return dav_acl_privilege_error(r, "unknown", NULL);
switch (r->method_number) {
default:
if (r->method_number == iM_ACL) {
return check_acl(r, resource, conf, repos);
}
else if (r->method_number == iM_HEAD) {
return check_get(r, resource, conf, repos);
}
else {
TRACE(r, "Unknown methdod:%d", r->method_number);
return NULL;
}
break;
case M_PUT:
return check_put(r, resource, conf, repos);
case M_PROPPATCH:
return check_proppatch(r, resource, conf, repos);
case M_MKCOL:
return check_mkcol(r, resource, conf, repos);
case M_PROPFIND:
/* done with individual properties within dav_get_props() and
* dav_get_allprops */
return NULL;
case M_DELETE:
return check_delete(r, resource, conf, repos);
case M_OPTIONS:
case M_GET:
return check_get(r, resource, conf, repos);
case M_COPY:
return check_copy(r, resource, conf, repos);
case M_MOVE:
return check_move(r, resource, conf, repos);
case M_LOCK:
return check_lock(r, resource, conf, repos);
case M_UNLOCK:
return check_unlock(r, resource, conf, repos);
}
}
static void
ct_generic(dbref player, dbref i, warn_type flags)
{
if ((flags & W_LOCK_PROBS)) {
lock_list *ll;
for (ll = Locks(i); ll; ll = L_NEXT(ll)) {
check_lock(player, i, L_TYPE(ll), L_KEY(ll));
}
}
}
int main(int argc, char **argv)
{
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
gethostname(hostname, 1023);
printf("%s rank %d hello world\n", hostname, rank);
check_lock(argv[1]);
MPI_Finalize();
}
int _spin_is_locked(spinlock_t *lock)
{
check_lock(&lock->debug);
/*
* Recursive locks may be locked by another CPU, yet we return
* "false" here, making this function suitable only for use in
* ASSERT()s and alike.
*/
return lock->recurse_cpu == SPINLOCK_NO_CPU
? lock->tickets.head != lock->tickets.tail
: lock->recurse_cpu == smp_processor_id();
}
void _spin_lock_irq(spinlock_t *lock)
{
ASSERT(local_irq_is_enabled());
local_irq_disable();
check_lock(&lock->debug);
while ( unlikely(!_raw_spin_trylock(&lock->raw)) )
{
local_irq_enable();
while ( likely(_raw_spin_is_locked(&lock->raw)) )
cpu_relax();
local_irq_disable();
}
}
/** Write lock
**/
extern "C" void wlock(unsigned int *lock)
{
unsigned int timeout = MAXSPIN;
unsigned int value;
extern unsigned int wlock_count, wlock_spin;
check_lock(lock,true,false);
atomic_increment(&wlock_count);
do {
value = (*lock);
atomic_increment(&wlock_spin);
if ( timeout--==0 )
throw_exception("write lock timeout");
} while ((value&1) || !atomic_compare_and_swap(lock, value, value + 1));
}
unsigned long _spin_lock_irqsave(spinlock_t *lock)
{
unsigned long flags;
local_irq_save(flags);
check_lock(&lock->debug);
while ( unlikely(!_raw_spin_trylock(&lock->raw)) )
{
local_irq_restore(flags);
while ( likely(_raw_spin_is_locked(&lock->raw)) )
cpu_relax();
local_irq_save(flags);
}
return flags;
}
void _spin_lock(spinlock_t *lock)
{
spinlock_tickets_t tickets = SPINLOCK_TICKET_INC;
LOCK_PROFILE_VAR;
check_lock(&lock->debug);
tickets.head_tail = arch_fetch_and_add(&lock->tickets.head_tail,
tickets.head_tail);
while ( tickets.tail != observe_head(&lock->tickets) )
{
LOCK_PROFILE_BLOCK;
arch_lock_relax();
}
LOCK_PROFILE_GOT;
preempt_disable();
arch_lock_acquire_barrier();
}
int
main(int argc, char **argv)
{
int ch, debug = 0, uucpstyle = 0;
const char *file = NULL;
char *endptr;
pid_t pid = -1;
long tmp_pid;
while ((ch = getopt(argc, argv, "df:p:u")) != -1) {
switch (ch) {
case 'd':
debug = 1;
break;
case 'f':
file = optarg;
break;
case 'p':
errno = 0;
tmp_pid = strtol(optarg, &endptr, 10);
if (*endptr != '\0' || errno ||
tmp_pid < 1 || (pid = tmp_pid) != tmp_pid)
errx(1, "invalid pid specified");
break;
case 'u':
uucpstyle = 1;
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc != 0)
usage();
if (file == NULL)
usage();
if (pid != -1)
return(create_lock(file, pid, uucpstyle, debug));
else
return(check_lock(file, uucpstyle, debug));
}
void inline _spin_lock_cb(spinlock_t *lock, void (*cb)(void *), void *data)
{
spinlock_tickets_t tickets = SPINLOCK_TICKET_INC;
LOCK_PROFILE_VAR;
check_lock(&lock->debug);
tickets.head_tail = arch_fetch_and_add(&lock->tickets.head_tail,
tickets.head_tail);
while ( tickets.tail != observe_head(&lock->tickets) )
{
LOCK_PROFILE_BLOCK;
if ( unlikely(cb) )
cb(data);
arch_lock_relax();
}
LOCK_PROFILE_GOT;
preempt_disable();
arch_lock_acquire_barrier();
}
void _spin_lock_recursive(spinlock_t *lock)
{
int cpu = smp_processor_id();
/* Don't allow overflow of recurse_cpu field. */
BUILD_BUG_ON(NR_CPUS > 0xfffu);
check_lock(&lock->debug);
if ( likely(lock->recurse_cpu != cpu) )
{
spin_lock(lock);
lock->recurse_cpu = cpu;
}
/* We support only fairly shallow recursion, else the counter overflows. */
ASSERT(lock->recurse_cnt < 0xfu);
lock->recurse_cnt++;
}
void lock(lock_t *_lock)
{
pid_t pid = getpid();
while (_lock->lock == LOCKED) {
if (_lock->owner == pid) {
debugf("lol, already have lock!\n");
show_backtrace();
panic(EXIT_LOCKING_CATASTROPHE);
_exit(EXIT_FAILURE);
}
/* This is pretty horrible. But if we call lock()
* from the watchdog code, and a child is hogging a lock
* (or worse, a dead child), we'll never call check_lock()
* from the watchdog loop because we'll be stuck here.
*/
if (pid == watchdog_pid) {
check_lock(_lock);
} else {
/* Ok, we're a child pid.
* if something bad happened, like main/watchdog crashed,
* we don't want to spin forever, so just get out.
*/
if ((shm->exit_reason != STILL_RUNNING) &&
(shm->exit_reason != EXIT_REACHED_COUNT)) {
_exit(EXIT_FAILURE);
}
}
_lock->contention++;
usleep(1);
}
_lock->lock = LOCKED;
_lock->contention = 0;
_lock->owner = pid;
}
static void check_locks(THR_LOCK *lock, const char *where,
my_bool allow_no_locks)
{
uint old_found_errors=found_errors;
DBUG_ENTER("check_locks");
if (found_errors < MAX_FOUND_ERRORS)
{
if (check_lock(&lock->write,"write",where,1,1) |
check_lock(&lock->write_wait,"write_wait",where,0,0) |
check_lock(&lock->read,"read",where,0,1) |
check_lock(&lock->read_wait,"read_wait",where,0,0))
found_errors++;
if (found_errors < MAX_FOUND_ERRORS)
{
uint count=0;
THR_LOCK_DATA *data;
for (data=lock->read.data ; data ; data=data->next)
{
if ((int) data->type == (int) TL_READ_NO_INSERT)
count++;
/* Protect against infinite loop. */
DBUG_ASSERT(count <= lock->read_no_write_count);
}
if (count != lock->read_no_write_count)
{
found_errors++;
fprintf(stderr,
"Warning at '%s': Locks read_no_write_count was %u when it should have been %u\n", where, lock->read_no_write_count,count);
}
if (!lock->write.data)
{
if (!allow_no_locks && !lock->read.data &&
(lock->write_wait.data || lock->read_wait.data))
{
found_errors++;
fprintf(stderr,
"Warning at '%s': No locks in use but locks are in wait queue\n",
where);
}
if (!lock->write_wait.data)
{
if (!allow_no_locks && lock->read_wait.data)
{
found_errors++;
fprintf(stderr,
"Warning at '%s': No write locks and waiting read locks\n",
where);
}
}
else
{
if (!allow_no_locks &&
(((lock->write_wait.data->type == TL_WRITE_CONCURRENT_INSERT ||
lock->write_wait.data->type == TL_WRITE_ALLOW_WRITE) &&
!lock->read_no_write_count) ||
lock->write_wait.data->type == TL_WRITE_ALLOW_READ ||
(lock->write_wait.data->type == TL_WRITE_DELAYED &&
!lock->read.data)))
{
found_errors++;
fprintf(stderr,
"Warning at '%s': Write lock %d waiting while no exclusive read locks\n",where,(int) lock->write_wait.data->type);
}
}
}
else
{ /* Have write lock */
if (lock->write_wait.data)
{
if (!allow_no_locks &&
lock->write.data->type == TL_WRITE_ALLOW_WRITE &&
lock->write_wait.data->type == TL_WRITE_ALLOW_WRITE)
{
found_errors++;
fprintf(stderr,
"Warning at '%s': Found WRITE_ALLOW_WRITE lock waiting for WRITE_ALLOW_WRITE lock\n",
where);
}
}
if (lock->read.data)
{
if (!thr_lock_owner_equal(lock->write.data->owner,
lock->read.data->owner) &&
((lock->write.data->type > TL_WRITE_DELAYED &&
lock->write.data->type != TL_WRITE_ONLY) ||
((lock->write.data->type == TL_WRITE_CONCURRENT_INSERT ||
lock->write.data->type == TL_WRITE_ALLOW_WRITE) &&
lock->read_no_write_count)))
{
found_errors++;
fprintf(stderr,
"Warning at '%s': Found lock of type %d that is write and read locked\n",
where, lock->write.data->type);
DBUG_PRINT("warning",("At '%s': Found lock of type %d that is write and read locked\n",
where, lock->write.data->type));
}
}
if (lock->read_wait.data)
{
if (!allow_no_locks && lock->write.data->type <= TL_WRITE_DELAYED &&
lock->read_wait.data->type <= TL_READ_HIGH_PRIORITY)
{
found_errors++;
fprintf(stderr,
"Warning at '%s': Found read lock of type %d waiting for write lock of type %d\n",
where,
(int) lock->read_wait.data->type,
(int) lock->write.data->type);
}
}
}
}
if (found_errors != old_found_errors)
{
DBUG_PRINT("error",("Found wrong lock"));
}
}
DBUG_VOID_RETURN;
}
/** Write unlock
**/
extern "C" void wunlock(unsigned int *lock)
{
unsigned int value = *lock;
check_lock(lock,true,true);
atomic_increment(lock);
}
const QVector<RecordLine>& RecordList::matching_record_info() const {
check_lock();
return *matching_records;
}
const QVector<MoteHeader>& RecordList::matching_headers() const {
check_lock();
return *matching_header;
}
const QVector<RecordLine>& RecordList::record_info() const {
check_lock();
return *records;
}
const QVector<MoteHeader>& RecordList::headers() const {
check_lock();
return *header;
}
/* run the ping pong test on fd */
static void ping_pong(int fd, int num_locks)
{
unsigned count = 0;
int i=0, loops=0;
unsigned char *val;
unsigned char incr=0, last_incr=0;
unsigned char *p = NULL;
int ret;
ret = ftruncate(fd, num_locks+1);
if (ret == -1) {
printf("ftruncate failed: %s\n", strerror(errno));
return;
}
if (use_mmap) {
p = mmap(NULL, num_locks+1, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
if (p == MAP_FAILED) {
printf("mmap failed: %s\n", strerror(errno));
return;
}
}
val = (unsigned char *)calloc(num_locks+1, sizeof(unsigned char));
if (val == NULL) {
printf("calloc failed\n");
return;
}
start_timer();
lock_range(fd, 0, 1);
i = 0;
while (1) {
if (lock_range(fd, (i+1) % num_locks, 1) != 0) {
printf("lock at %d failed! - %s\n",
(i+1) % num_locks, strerror(errno));
}
if (do_check) {
ret = check_lock(fd, i, 1);
}
if (do_reads) {
unsigned char c;
if (use_mmap) {
c = p[i];
} else if (pread(fd, &c, 1, i) != 1) {
printf("read failed at %d\n", i);
}
incr = c - val[i];
val[i] = c;
}
if (do_writes) {
char c = val[i] + 1;
if (use_mmap) {
p[i] = c;
} else if (pwrite(fd, &c, 1, i) != 1) {
printf("write failed at %d\n", i);
}
}
if (unlock_range(fd, i, 1) != 0) {
printf("unlock at %d failed! - %s\n",
i, strerror(errno));
}
i = (i+1) % num_locks;
count++;
if (loops > num_locks && incr != last_incr) {
last_incr = incr;
printf("data increment = %u\n", incr);
fflush(stdout);
}
if (end_timer() > 1.0) {
printf("%8u locks/sec\r",
(unsigned)(2*count/end_timer()));
fflush(stdout);
start_timer();
count=0;
}
loops++;
}
}
