Attachment #17878 for bug #38758

View | Details | Raw Unified | Return to bug 38758
Collapse All | Expand All




    return APR_SUCCESS;
}

static apr_status_t proc_mutex_posix_tryacquire(apr_proc_mutex_t *mutex)
{
    if (sem_trywait(mutex->psem_interproc) < 0) {
        if (errno == EAGAIN) {
            return APR_EBUSY;
        }
        return errno;
    }
    mutex->curr_locked = 1;
    return APR_SUCCESS;
}

static apr_status_t proc_mutex_posix_release(apr_proc_mutex_t *mutex)
{
    mutex->curr_locked = 0;

#endif
    proc_mutex_posix_create,
    proc_mutex_posix_acquire,
    proc_mutex_posix_tryacquire,
    proc_mutex_posix_release,
    proc_mutex_posix_cleanup,
    proc_mutex_no_child_init,

#if APR_HAS_SYSVSEM_SERIALIZE

static struct sembuf proc_mutex_op_on;
static struct sembuf proc_mutex_op_try;
static struct sembuf proc_mutex_op_off;

static void proc_mutex_sysv_setup(void)

    proc_mutex_op_on.sem_num = 0;
    proc_mutex_op_on.sem_op = -1;
    proc_mutex_op_on.sem_flg = SEM_UNDO;
    proc_mutex_op_try.sem_num = 0;
    proc_mutex_op_try.sem_op = -1;
    proc_mutex_op_try.sem_flg = SEM_UNDO | IPC_NOWAIT;
    proc_mutex_op_off.sem_num = 0;
    proc_mutex_op_off.sem_op = 1;
    proc_mutex_op_off.sem_flg = SEM_UNDO;

    return APR_SUCCESS;
}

static apr_status_t proc_mutex_sysv_tryacquire(apr_proc_mutex_t *mutex)
{
    int rc;

    do {
        rc = semop(mutex->interproc->filedes, &proc_mutex_op_try, 1);
    } while (rc < 0 && errno == EINTR);
    if (rc < 0) {
        if (errno == EAGAIN) {
            return APR_EBUSY;
        }
        return errno;
    }
    mutex->curr_locked = 1;
    return APR_SUCCESS;
}

static apr_status_t proc_mutex_sysv_release(apr_proc_mutex_t *mutex)
{
    int rc;

#endif
    proc_mutex_sysv_create,
    proc_mutex_sysv_acquire,
    proc_mutex_sysv_tryacquire,
    proc_mutex_sysv_release,
    proc_mutex_sysv_cleanup,
    proc_mutex_no_child_init,

    return APR_SUCCESS;
}

static apr_status_t proc_mutex_proc_pthread_tryacquire(apr_proc_mutex_t *mutex)
{
    apr_status_t rv;
 
    if ((rv = pthread_mutex_trylock(mutex->pthread_interproc))) {
#ifdef PTHREAD_SETS_ERRNO
        rv = errno;
#endif
        if (rv == EBUSY) {
            return APR_EBUSY;
        }
#ifdef HAVE_PTHREAD_MUTEXATTR_SETROBUST_NP
        /* Okay, our owner died.  Let's try to make it consistent again. */
        if (rv == EOWNERDEAD) {
            pthread_mutex_consistent_np(mutex->pthread_interproc);
            rv = APR_SUCCESS;
        }
        else
            return rv;
#else
        return rv;
#endif
    }
    mutex->curr_locked = 1;
    return rv;
}

static apr_status_t proc_mutex_proc_pthread_release(apr_proc_mutex_t *mutex)
{

    APR_PROCESS_LOCK_MECH_IS_GLOBAL,
    proc_mutex_proc_pthread_create,
    proc_mutex_proc_pthread_acquire,
    proc_mutex_proc_pthread_tryacquire,
    proc_mutex_proc_pthread_release,
    proc_mutex_proc_pthread_cleanup,
    proc_mutex_no_child_init,

    if (rc < 0) {
        return errno;
    }
    mutex->curr_locked = 1;
    return APR_SUCCESS;
}

static apr_status_t proc_mutex_fcntl_tryacquire(apr_proc_mutex_t *mutex)
{
    int rc;

    do {
        rc = fcntl(mutex->interproc->filedes, F_SETLK, &proc_mutex_lock_it);
    } while (rc < 0 && errno == EINTR);
    if (rc < 0) {
        if (errno == EAGAIN) {
            return APR_EBUSY;
        }
        return errno;
    }
    mutex->curr_locked = 1;
    return APR_SUCCESS;
}


#endif
    proc_mutex_fcntl_create,
    proc_mutex_fcntl_acquire,
    proc_mutex_fcntl_tryacquire,
    proc_mutex_fcntl_release,
    proc_mutex_fcntl_cleanup,
    proc_mutex_no_child_init,

    return APR_SUCCESS;
}

static apr_status_t proc_mutex_flock_tryacquire(apr_proc_mutex_t *mutex)
{
    int rc;

    do {
        rc = flock(mutex->interproc->filedes, LOCK_EX | LOCK_NB);
    } while (rc < 0 && errno == EINTR);
    if (rc < 0) {
        if (errno == EWOULDBLOCK) {
            return APR_EBUSY;
        }
        return errno;
    }
    mutex->curr_locked = 1;
    return APR_SUCCESS;
}

static apr_status_t proc_mutex_flock_release(apr_proc_mutex_t *mutex)
{
    int rc;

#endif
    proc_mutex_flock_create,
    proc_mutex_flock_acquire,
    proc_mutex_flock_tryacquire,
    proc_mutex_flock_release,
    proc_mutex_flock_cleanup,
    proc_mutex_flock_child_init,

Return to bug 38758

Lines 125-130 Link Here

(-)locks/unix/proc_mutex.c.orig (-7 / +99 lines)
125	return APR_SUCCESS;	125	return APR_SUCCESS;
126	}	126	}
127		127
		128	static apr_status_t proc_mutex_posix_tryacquire(apr_proc_mutex_t *mutex)
		129	{
		130	if (sem_trywait(mutex->psem_interproc) < 0) {
		131	if (errno == EAGAIN) {
		132	return APR_EBUSY;
		133	}
		134	return errno;
		135	}
		136	mutex->curr_locked = 1;
		137	return APR_SUCCESS;
		138	}
		139
128	static apr_status_t proc_mutex_posix_release(apr_proc_mutex_t *mutex)	140	static apr_status_t proc_mutex_posix_release(apr_proc_mutex_t *mutex)
129	{	141	{
130	mutex->curr_locked = 0;	142	mutex->curr_locked = 0;
Lines 145-151 Link Here
145	#endif	157	#endif
146	proc_mutex_posix_create,	158	proc_mutex_posix_create,
147	proc_mutex_posix_acquire,	159	proc_mutex_posix_acquire,
148	proc_mutex_no_tryacquire,	160	proc_mutex_posix_tryacquire,
149	proc_mutex_posix_release,	161	proc_mutex_posix_release,
150	proc_mutex_posix_cleanup,	162	proc_mutex_posix_cleanup,
151	proc_mutex_no_child_init,	163	proc_mutex_no_child_init,
Lines 157-162 Link Here
157	#if APR_HAS_SYSVSEM_SERIALIZE	169	#if APR_HAS_SYSVSEM_SERIALIZE
158		170
159	static struct sembuf proc_mutex_op_on;	171	static struct sembuf proc_mutex_op_on;
		172	static struct sembuf proc_mutex_op_try;
160	static struct sembuf proc_mutex_op_off;	173	static struct sembuf proc_mutex_op_off;
161		174
162	static void proc_mutex_sysv_setup(void)	175	static void proc_mutex_sysv_setup(void)
Lines 164-169 Link Here
164	proc_mutex_op_on.sem_num = 0;	177	proc_mutex_op_on.sem_num = 0;
165	proc_mutex_op_on.sem_op = -1;	178	proc_mutex_op_on.sem_op = -1;
166	proc_mutex_op_on.sem_flg = SEM_UNDO;	179	proc_mutex_op_on.sem_flg = SEM_UNDO;
		180	proc_mutex_op_try.sem_num = 0;
		181	proc_mutex_op_try.sem_op = -1;
		182	proc_mutex_op_try.sem_flg = SEM_UNDO \| IPC_NOWAIT;
167	proc_mutex_op_off.sem_num = 0;	183	proc_mutex_op_off.sem_num = 0;
168	proc_mutex_op_off.sem_op = 1;	184	proc_mutex_op_off.sem_op = 1;
169	proc_mutex_op_off.sem_flg = SEM_UNDO;	185	proc_mutex_op_off.sem_flg = SEM_UNDO;
Lines 222-227 Link Here
222	return APR_SUCCESS;	238	return APR_SUCCESS;
223	}	239	}
224		240
		241	static apr_status_t proc_mutex_sysv_tryacquire(apr_proc_mutex_t *mutex)
		242	{
		243	int rc;
		244
		245	do {
		246	rc = semop(mutex->interproc->filedes, &proc_mutex_op_try, 1);
		247	} while (rc < 0 && errno == EINTR);
		248	if (rc < 0) {
		249	if (errno == EAGAIN) {
		250	return APR_EBUSY;
		251	}
		252	return errno;
		253	}
		254	mutex->curr_locked = 1;
		255	return APR_SUCCESS;
		256	}
		257
225	static apr_status_t proc_mutex_sysv_release(apr_proc_mutex_t *mutex)	258	static apr_status_t proc_mutex_sysv_release(apr_proc_mutex_t *mutex)
226	{	259	{
227	int rc;	260	int rc;
Lines 245-251 Link Here
245	#endif	278	#endif
246	proc_mutex_sysv_create,	279	proc_mutex_sysv_create,
247	proc_mutex_sysv_acquire,	280	proc_mutex_sysv_acquire,
248	proc_mutex_no_tryacquire,	281	proc_mutex_sysv_tryacquire,
249	proc_mutex_sysv_release,	282	proc_mutex_sysv_release,
250	proc_mutex_sysv_cleanup,	283	proc_mutex_sysv_cleanup,
251	proc_mutex_no_child_init,	284	proc_mutex_no_child_init,
Lines 394-400 Link Here
394	return APR_SUCCESS;	427	return APR_SUCCESS;
395	}	428	}
396		429
397	/* TODO: Add proc_mutex_proc_pthread_tryacquire(apr_proc_mutex_t mutex) /	430	static apr_status_t proc_mutex_proc_pthread_tryacquire(apr_proc_mutex_t *mutex)
		431	{
		432	apr_status_t rv;
		433
		434	if ((rv = pthread_mutex_trylock(mutex->pthread_interproc))) {
		435	#ifdef PTHREAD_SETS_ERRNO
		436	rv = errno;
		437	#endif
		438	if (rv == EBUSY) {
		439	return APR_EBUSY;
		440	}
		441	#ifdef HAVE_PTHREAD_MUTEXATTR_SETROBUST_NP
		442	/* Okay, our owner died. Let's try to make it consistent again. */
		443	if (rv == EOWNERDEAD) {
		444	pthread_mutex_consistent_np(mutex->pthread_interproc);
		445	rv = APR_SUCCESS;
		446	}
		447	else
		448	return rv;
		449	#else
		450	return rv;
		451	#endif
		452	}
		453	mutex->curr_locked = 1;
		454	return rv;
		455	}
398		456
399	static apr_status_t proc_mutex_proc_pthread_release(apr_proc_mutex_t *mutex)	457	static apr_status_t proc_mutex_proc_pthread_release(apr_proc_mutex_t *mutex)
400	{	458	{
Lines 415-421 Link Here
415	APR_PROCESS_LOCK_MECH_IS_GLOBAL,	473	APR_PROCESS_LOCK_MECH_IS_GLOBAL,
416	proc_mutex_proc_pthread_create,	474	proc_mutex_proc_pthread_create,
417	proc_mutex_proc_pthread_acquire,	475	proc_mutex_proc_pthread_acquire,
418	proc_mutex_no_tryacquire,	476	proc_mutex_proc_pthread_tryacquire,
419	proc_mutex_proc_pthread_release,	477	proc_mutex_proc_pthread_release,
420	proc_mutex_proc_pthread_cleanup,	478	proc_mutex_proc_pthread_cleanup,
421	proc_mutex_no_child_init,	479	proc_mutex_no_child_init,
Lines 501-507 Link Here
501	if (rc < 0) {	559	if (rc < 0) {
502	return errno;	560	return errno;
503	}	561	}
504	mutex->curr_locked=1;	562	mutex->curr_locked = 1;
		563	return APR_SUCCESS;
		564	}
		565
		566	static apr_status_t proc_mutex_fcntl_tryacquire(apr_proc_mutex_t *mutex)
		567	{
		568	int rc;
		569
		570	do {
		571	rc = fcntl(mutex->interproc->filedes, F_SETLK, &proc_mutex_lock_it);
		572	} while (rc < 0 && errno == EINTR);
		573	if (rc < 0) {
		574	if (errno == EAGAIN) {
		575	return APR_EBUSY;
		576	}
		577	return errno;
		578	}
		579	mutex->curr_locked = 1;
505	return APR_SUCCESS;	580	return APR_SUCCESS;
506	}	581	}
507		582
Lines 528-534 Link Here
528	#endif	603	#endif
529	proc_mutex_fcntl_create,	604	proc_mutex_fcntl_create,
530	proc_mutex_fcntl_acquire,	605	proc_mutex_fcntl_acquire,
531	proc_mutex_no_tryacquire,	606	proc_mutex_fcntl_tryacquire,
532	proc_mutex_fcntl_release,	607	proc_mutex_fcntl_release,
533	proc_mutex_fcntl_cleanup,	608	proc_mutex_fcntl_cleanup,
534	proc_mutex_no_child_init,	609	proc_mutex_no_child_init,
Lines 602-607 Link Here
602	return APR_SUCCESS;	677	return APR_SUCCESS;
603	}	678	}
604		679
		680	static apr_status_t proc_mutex_flock_tryacquire(apr_proc_mutex_t *mutex)
		681	{
		682	int rc;
		683
		684	do {
		685	rc = flock(mutex->interproc->filedes, LOCK_EX \| LOCK_NB);
		686	} while (rc < 0 && errno == EINTR);
		687	if (rc < 0) {
		688	if (errno == EWOULDBLOCK) {
		689	return APR_EBUSY;
		690	}
		691	return errno;
		692	}
		693	mutex->curr_locked = 1;
		694	return APR_SUCCESS;
		695	}
		696
605	static apr_status_t proc_mutex_flock_release(apr_proc_mutex_t *mutex)	697	static apr_status_t proc_mutex_flock_release(apr_proc_mutex_t *mutex)
606	{	698	{
607	int rc;	699	int rc;
Lines 649-655 Link Here
649	#endif	741	#endif
650	proc_mutex_flock_create,	742	proc_mutex_flock_create,
651	proc_mutex_flock_acquire,	743	proc_mutex_flock_acquire,
652	proc_mutex_no_tryacquire,	744	proc_mutex_flock_tryacquire,
653	proc_mutex_flock_release,	745	proc_mutex_flock_release,
654	proc_mutex_flock_cleanup,	746	proc_mutex_flock_cleanup,
655	proc_mutex_flock_child_init,	747	proc_mutex_flock_child_init,