/** @file

  A brief file description

  @section license License

  Licensed to the Apache Software Foundation (ASF) under one
  or more contributor license agreements.  See the NOTICE file
  distributed with this work for additional information
  regarding copyright ownership.  The ASF licenses this file
  to you under the Apache License, Version 2.0 (the
  "License"); you may not use this file except in compliance
  with the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
 */

#ifndef _ink_mutex_h_
#define _ink_mutex_h_

/***********************************************************************

    Fast Mutex

    Uses atomic memory operations to minimize blocking.


***********************************************************************/
#include <stdio.h>

#include "ink_port.h"

#if defined(POSIX_THREAD)
#include <pthread.h>
#include <stdlib.h>

typedef pthread_mutex_t ProcessMutex;
typedef ProcessMutex ink_mutex;
typedef ProcessMutex InkMutex;

// just a wrapper so that the constructor gets executed
// before the first call to ink_mutex_init();
class x_pthread_mutexattr_t
{
public:
  pthread_mutexattr_t attr;
  x_pthread_mutexattr_t();
  ~x_pthread_mutexattr_t()
  {
  }
};

inline
x_pthread_mutexattr_t::x_pthread_mutexattr_t()
{
  pthread_mutexattr_init(&attr);
#ifndef POSIX_THREAD_10031c
  pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
#endif
}

static x_pthread_mutexattr_t _g_mattr;

static inline int
ink_mutex_init(ink_mutex * m, const char *name)
{
  (void) name;

#if defined(solaris)
  if ( pthread_mutex_init(m, NULL) != 0 ) {
    abort();
  }
#else
  if (pthread_mutex_init(m, &_g_mattr.attr) != 0) {
    abort();
  }
#endif
  return 0;
}

static inline int
ink_mutex_init_ex(ink_mutex * m, const char *name, int thread_safe)
{
	if (thread_safe)
		return 0;
	else
		return ink_mutex_init(m, name);
}

static inline int
ink_mutex_destroy(ink_mutex * m)
{
  return pthread_mutex_destroy(m);
}

static inline int
ink_mutex_destroy_ex(ink_mutex * m, int thread_safe)
{
	if (thread_safe)
		return 0;
	else
	  return ink_mutex_destroy(m);
}

static inline int
ink_mutex_acquire(ink_mutex * m)
{
  if (pthread_mutex_lock(m) != 0) {
    abort();
  }
  return 0;
}

static inline int
ink_mutex_acquire_ex(ink_mutex * m, int thread_safe)
{
	if (thread_safe)
		return 0;
	else
		return ink_mutex_acquire(m);
}

static inline int
ink_mutex_release(ink_mutex * m)
{
  if (pthread_mutex_unlock(m) != 0) {
    abort();
  }
  return 0;
}

static inline int
ink_mutex_release_ex(ink_mutex * m, int thread_safe)
{
  if (thread_safe)
    return 0;
    else
      return ink_mutex_release(m);
}

static inline int
ink_mutex_try_acquire(ink_mutex * m)
{
  return pthread_mutex_trylock(m) == 0;
}

#endif /* #if defined(POSIX_THREAD) */


/* process mutex */

void ink_ProcessMutex_init(ProcessMutex *, const char *name);
void ink_ProcessMutex_destroy(ProcessMutex *);
void ink_ProcessMutex_acquire(ProcessMutex *);
void ink_ProcessMutex_release(ProcessMutex *);
int ink_ProcessMutex_try_acquire(ProcessMutex *);
void ink_ProcessMutex_print(FILE * out, ProcessMutex *);


struct ink_scoped_mutex
{
  explicit ink_scoped_mutex(ink_mutex& m) : mtx(m) {
    ink_mutex_acquire(&mtx);
  }

  ~ink_scoped_mutex() {
    ink_mutex_release(&mtx);
  }

private:
  ink_mutex& mtx;
};

#endif /* _ink_mutex_h_ */
