Error handling issues for pthread_mutex_lock

[ycaibb]

Hi, I have a suggestion about error handlings for locking. Would it be better to handle the possible errors that return from pthread_mutex_lock.

hubicfuse/cloudfsapi.c

Lines 104 to 112 in 788b9db

	pthread_mutex_lock(&pool_mut);
	CURL* curl = curl_pool_count ? curl_pool[--curl_pool_count] : curl_easy_init();
	if (!curl)
	{
	debugf(DBG_LEVEL_NORM, KRED"curl alloc failed");
	pthread_mutex_unlock(&pool_mut);
	abort();
	}
	pthread_mutex_unlock(&pool_mut);

hubicfuse/commonfs.c

Lines 461 to 466 in b460f40

	pthread_mutex_lock(&dcachemut);
	bool new_entry = false;
	if (!strcmp(path, "/"))
	path = "";
	dir_cache* cw;
	for (cw = dcache; cw; cw = cw->next)

Possible situations that return errors.

  EAGAIN The mutex could not be acquired because the maximum number
              of recursive locks for mutex has been exceeded.

       EINVAL The mutex was created with the protocol attribute having
              the value PTHREAD_PRIO_PROTECT and the calling thread's
              priority is higher than the mutex's current priority
              ceiling.

       ENOTRECOVERABLE
              The state protected by the mutex is not recoverable.

       EOWNERDEAD
              The mutex is a robust mutex and the process containing the
              previous owning thread terminated while holding the mutex
              lock. The mutex lock shall be acquired by the calling
              thread and it is up to the new owner to make the state
              consistent.

       EDEADLK
              The mutex type is PTHREAD_MUTEX_ERRORCHECK and the current
              thread already owns the mutex.

       EOWNERDEAD
              The mutex is a robust mutex and the previous owning thread
              terminated while holding the mutex lock. The mutex lock
              shall be acquired by the calling thread and it is up to
              the new owner to make the state consistent.

       EDEADLK
              A deadlock condition was detected.

For example, this example does not check the value returned by pthread_mutex_lock() for errors. If pthread_mutex_lock() cannot acquire the mutex for any reason, the function may introduce a race condition into the program (CWE-413). The manners of error handlings could be flagging any warnings or returning before accessing the critical region.

void f(pthread_mutex_t *mutex) {
pthread_mutex_lock(mutex);

/* access shared resource */


pthread_mutex_unlock(mutex);
}