/* -*- mode: C; c-file-style: "gnu" -*- */

/* dbus-threads.h  D-Bus threads handling

 *

 * Copyright (C) 2002, 2003, 2006 Red Hat Inc.

 * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

 * Licensed under the Academic Free License version 2.1

 * 

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 */

#include "dbus-threads.h"

#include "dbus-internals.h"

#include "dbus-threads-internal.h"

#include "dbus-list.h"

#ifdef __SYMBIAN32__

#include "libdbus_wsd_solution.h"

#endif

#if EMULATOR

int GET_DBUS_WSD_VAR_NAME(_dbus_current_generation,dbus_memory,g)();

#define _dbus_current_generation (GET_DBUS_WSD_VAR_NAME(_dbus_current_generation,dbus_memory,g)())

#endif

#if EMULATOR

GET_STATIC_ARRAY_FROM_TLS(thread_functions,dbus_threads,DBusThreadFunctions)

#define thread_functions (*GET_DBUS_WSD_VAR_NAME(thread_functions,dbus_threads,s)())

#else

static DBusThreadFunctions thread_functions =

{

  0,

  NULL, NULL, NULL, NULL, NULL,

  NULL, NULL, NULL, NULL, NULL,

  NULL, NULL, NULL, NULL,

  NULL, NULL, NULL, NULL

};

#endif

#ifndef EMULATOR

static int thread_init_generation = 0;

static DBusList *uninitialized_mutex_list = NULL;

static DBusList *uninitialized_condvar_list = NULL;

#else

GET_STATIC_VAR_FROM_TLS(thread_init_generation,dbus_threads,int)

#define thread_init_generation (*GET_DBUS_WSD_VAR_NAME(thread_init_generation,dbus_threads,s)())

GET_STATIC_VAR_FROM_TLS(uninitialized_mutex_list,dbus_threads,DBusList*)

#define uninitialized_mutex_list (*GET_DBUS_WSD_VAR_NAME(uninitialized_mutex_list,dbus_threads,s)())

GET_STATIC_VAR_FROM_TLS(uninitialized_condvar_list,dbus_threads,DBusList*)

#define uninitialized_condvar_list (*GET_DBUS_WSD_VAR_NAME(uninitialized_condvar_list,dbus_threads,s)())

#endif

/** This is used for the no-op default mutex pointer, just to be distinct from #NULL */

#define _DBUS_DUMMY_MUTEX ((DBusMutex*)0xABCDEF)

/** This is used for the no-op default mutex pointer, just to be distinct from #NULL */

#define _DBUS_DUMMY_CONDVAR ((DBusCondVar*)0xABCDEF2)

/**

 * @defgroup DBusThreadsInternals Thread functions

 * @ingroup  DBusInternals

 * @brief _dbus_mutex_lock(), etc.

 *

 * Functions and macros related to threads and thread locks.

 *

 * @{

 */

/**

 * Creates a new mutex using the function supplied to dbus_threads_init(),

 * or creates a no-op mutex if threads are not initialized.

 * May return #NULL even if threads are initialized, indicating

 * out-of-memory.

 *

 * @returns new mutex or #NULL

 */

DBusMutex*

_dbus_mutex_new (void)

{

  if (thread_functions.recursive_mutex_new)

    return (* thread_functions.recursive_mutex_new) ();

  else if (thread_functions.mutex_new)

    return (* thread_functions.mutex_new) ();

  else

    return _DBUS_DUMMY_MUTEX;

}

/**

 * This does the same thing as _dbus_mutex_new.  It however

 * gives another level of indirection by allocating a pointer

 * to point to the mutex location.  This allows the threading

 * module to swap out dummy mutexes for real a real mutex so libraries

 * can initialize threads even after the D-Bus API has been used.

 *

 * @param location_p the location of the new mutex, can return #NULL on OOM

 */

void

_dbus_mutex_new_at_location (DBusMutex **location_p)

{

  _dbus_assert (location_p != NULL);

  *location_p = _dbus_mutex_new();

  if (thread_init_generation != _dbus_current_generation && *location_p)

    {

      if (!_dbus_list_append (&uninitialized_mutex_list, location_p))

        {

	  _dbus_mutex_free (*location_p);

	  *location_p = NULL;

	}

    }

}

/**

 * Frees a mutex created with dbus_mutex_new(); does

 * nothing if passed a #NULL pointer.

 */

void

_dbus_mutex_free (DBusMutex *mutex)

{

  if (mutex)

    {

      if (mutex && thread_functions.recursive_mutex_free)

        (* thread_functions.recursive_mutex_free) (mutex);

      else if (mutex && thread_functions.mutex_free)

        (* thread_functions.mutex_free) (mutex);

    }

}

/**

 * Frees a mutex and removes it from the 

 * uninitialized_mutex_list;

 * does nothing if passed a #NULL pointer.

 */

void

_dbus_mutex_free_at_location (DBusMutex **location_p)

{

  if (location_p)

    {

      if (thread_init_generation != _dbus_current_generation)

        _dbus_list_remove (&uninitialized_mutex_list, location_p);

      _dbus_mutex_free (*location_p);

    }

}

/**

 * Locks a mutex. Does nothing if passed a #NULL pointer.

 * Locks may be recursive if threading implementation initialized

 * recursive locks.

 */

void

_dbus_mutex_lock (DBusMutex *mutex)

{

  if (mutex) 

    {

      if (thread_functions.recursive_mutex_lock)

        (* thread_functions.recursive_mutex_lock) (mutex);

      else if (thread_functions.mutex_lock)

        (* thread_functions.mutex_lock) (mutex);

    }

}

/**

 * Unlocks a mutex. Does nothing if passed a #NULL pointer.

 *

 * @returns #TRUE on success

 */

void

_dbus_mutex_unlock (DBusMutex *mutex)

{

  if (mutex)

    {

      if (thread_functions.recursive_mutex_unlock)

        (* thread_functions.recursive_mutex_unlock) (mutex);

      else if (thread_functions.mutex_unlock)

        (* thread_functions.mutex_unlock) (mutex);

    }

}

/**

 * Creates a new condition variable using the function supplied

 * to dbus_threads_init(), or creates a no-op condition variable

 * if threads are not initialized. May return #NULL even if

 * threads are initialized, indicating out-of-memory.

 *

 * @returns new mutex or #NULL

 */

DBusCondVar *

_dbus_condvar_new (void)

{

  if (thread_functions.condvar_new)

    return (* thread_functions.condvar_new) ();

  else

    return _DBUS_DUMMY_CONDVAR;

}

/**

 * This does the same thing as _dbus_condvar_new.  It however

 * gives another level of indirection by allocating a pointer

 * to point to the condvar location.  This allows the threading

 * module to swap out dummy condvars for real a real condvar so libraries

 * can initialize threads even after the D-Bus API has been used.

 *

 * @returns the location of a new condvar or #NULL on OOM

 */

void 

_dbus_condvar_new_at_location (DBusCondVar **location_p)

{

  *location_p = _dbus_condvar_new();

  if (thread_init_generation != _dbus_current_generation && *location_p)

    {

      if (!_dbus_list_append (&uninitialized_condvar_list, location_p))

        {

          _dbus_condvar_free (*location_p);

          *location_p = NULL;

        }

    }

}

/**

 * Frees a conditional variable created with dbus_condvar_new(); does

 * nothing if passed a #NULL pointer.

 */

void

_dbus_condvar_free (DBusCondVar *cond)

{

  if (cond && thread_functions.condvar_free)

    (* thread_functions.condvar_free) (cond);

}

/**

 * Frees a conditional variable and removes it from the 

 * uninitialized_condvar_list; 

 * does nothing if passed a #NULL pointer.

 */

void

_dbus_condvar_free_at_location (DBusCondVar **location_p)

{

  if (location_p)

    {

      if (thread_init_generation != _dbus_current_generation)

        _dbus_list_remove (&uninitialized_condvar_list, location_p);

      _dbus_condvar_free (*location_p);

    }

}

/**

 * Atomically unlocks the mutex and waits for the conditions

 * variable to be signalled. Locks the mutex again before

 * returning.

 * Does nothing if passed a #NULL pointer.

 */

void

_dbus_condvar_wait (DBusCondVar *cond,

                    DBusMutex   *mutex)

{

  if (cond && mutex && thread_functions.condvar_wait)

    (* thread_functions.condvar_wait) (cond, mutex);

}

/**

 * Atomically unlocks the mutex and waits for the conditions variable

 * to be signalled, or for a timeout. Locks the mutex again before

 * returning.  Does nothing if passed a #NULL pointer.  Return value

 * is #FALSE if we timed out, #TRUE otherwise.

 *

 * @param cond the condition variable

 * @param mutex the mutex

 * @param timeout_milliseconds the maximum time to wait

 * @returns #FALSE if the timeout occurred, #TRUE if not

 */

dbus_bool_t

_dbus_condvar_wait_timeout (DBusCondVar               *cond,

                            DBusMutex                 *mutex,

                            int                        timeout_milliseconds)

{

  if (cond && mutex && thread_functions.condvar_wait)

    return (* thread_functions.condvar_wait_timeout) (cond, mutex, timeout_milliseconds);

  else

    return TRUE;

}

/**

 * If there are threads waiting on the condition variable, wake

 * up exactly one. 

 * Does nothing if passed a #NULL pointer.

 */

void

_dbus_condvar_wake_one (DBusCondVar *cond)

{

  if (cond && thread_functions.condvar_wake_one)

    (* thread_functions.condvar_wake_one) (cond);

}

/**

 * If there are threads waiting on the condition variable, wake

 * up all of them. 

 * Does nothing if passed a #NULL pointer.

 */

void

_dbus_condvar_wake_all (DBusCondVar *cond)

{

  if (cond && thread_functions.condvar_wake_all)

    (* thread_functions.condvar_wake_all) (cond);

}

static void

shutdown_global_locks (void *data)

{

  DBusMutex ***locks = data;

  int i;

  i = 0;

  while (i < _DBUS_N_GLOBAL_LOCKS)

    {

      _dbus_mutex_free (*(locks[i]));

      *(locks[i]) = NULL;

      ++i;

    }

  dbus_free (locks);

}

static void

shutdown_uninitialized_locks (void *data)

{

  _dbus_list_clear (&uninitialized_mutex_list);

  _dbus_list_clear (&uninitialized_condvar_list);

}

static dbus_bool_t

init_uninitialized_locks (void)

{

  DBusList *link;

  _dbus_assert (thread_init_generation != _dbus_current_generation);

  link = uninitialized_mutex_list;

  while (link != NULL)

    {

      DBusMutex **mp;

      mp = (DBusMutex **)link->data;

      _dbus_assert (*mp == _DBUS_DUMMY_MUTEX);

      *mp = _dbus_mutex_new ();

      if (*mp == NULL)

        goto fail_mutex;

      link = _dbus_list_get_next_link (&uninitialized_mutex_list, link);

    }

  link = uninitialized_condvar_list;

  while (link != NULL)

    {

      DBusCondVar **cp;

      cp = (DBusCondVar **)link->data;

      _dbus_assert (*cp == _DBUS_DUMMY_CONDVAR);

      *cp = _dbus_condvar_new ();

      if (*cp == NULL)

        goto fail_condvar;

      link = _dbus_list_get_next_link (&uninitialized_condvar_list, link);

    }

  _dbus_list_clear (&uninitialized_mutex_list);

  _dbus_list_clear (&uninitialized_condvar_list);

  if (!_dbus_register_shutdown_func (shutdown_uninitialized_locks,

                                     NULL))

    goto fail_condvar;

  return TRUE;

 fail_condvar:

  link = uninitialized_condvar_list;

  while (link != NULL)

    {

      DBusCondVar **cp;

      cp = (DBusCondVar **)link->data;

      if (*cp != _DBUS_DUMMY_CONDVAR)

        _dbus_condvar_free (*cp);

      else

        break;

      *cp = _DBUS_DUMMY_CONDVAR;

      link = _dbus_list_get_next_link (&uninitialized_condvar_list, link);

    }

 fail_mutex:

  link = uninitialized_mutex_list;

  while (link != NULL)

    {

      DBusMutex **mp;

      mp = (DBusMutex **)link->data;

      if (*mp != _DBUS_DUMMY_MUTEX)

        _dbus_mutex_free (*mp);

      else

        break;

      *mp = _DBUS_DUMMY_MUTEX;

      link = _dbus_list_get_next_link (&uninitialized_mutex_list, link);

    }

  return FALSE;

}

#if EMULATOR

 DBusMutex  * GET_DBUS_WSD_VAR_NAME(_dbus_lock_bus,dbus_bus,g)();

#define _dbus_lock_bus (*GET_DBUS_WSD_VAR_NAME(_dbus_lock_bus,dbus_bus,g)())

DBusMutex  * GET_DBUS_WSD_VAR_NAME(_dbus_lock_bus_datas,dbus_bus,g)();

#define _dbus_lock_bus_datas (*GET_DBUS_WSD_VAR_NAME(_dbus_lock_bus_datas,dbus_bus,g)())

DBusMutex  * GET_DBUS_WSD_VAR_NAME(_dbus_lock_shared_connections,dbus_connection,g)();

#define _dbus_lock_shared_connections (*GET_DBUS_WSD_VAR_NAME(_dbus_lock_shared_connections,dbus_connection,g)())

DBusMutex  * GET_DBUS_WSD_VAR_NAME(_dbus_lock_message_cache,dbus_message,g)();

#define _dbus_lock_message_cache (*GET_DBUS_WSD_VAR_NAME(_dbus_lock_message_cache,dbus_message,g)())

DBusMutex  * GET_DBUS_WSD_VAR_NAME(_dbus_lock_message_slots,dbus_message,g)();

#define _dbus_lock_message_slots (*GET_DBUS_WSD_VAR_NAME(_dbus_lock_message_slots,dbus_message,g)())

DBusMutex  * GET_DBUS_WSD_VAR_NAME(_dbus_lock_pending_call_slots,dbus_pending_call,g)();

#define _dbus_lock_pending_call_slots (*GET_DBUS_WSD_VAR_NAME(_dbus_lock_pending_call_slots,dbus_pending_call,g)())

DBusMutex  * GET_DBUS_WSD_VAR_NAME(_dbus_lock_server_slots,dbus_server,g)();

#define _dbus_lock_server_slots (*GET_DBUS_WSD_VAR_NAME(_dbus_lock_server_slots,dbus_server,g)())

DBusMutex  * GET_DBUS_WSD_VAR_NAME(_dbus_lock_machine_uuid,dbus_internals,g)();

#define _dbus_lock_machine_uuid (*GET_DBUS_WSD_VAR_NAME(_dbus_lock_machine_uuid,dbus_internals,g)())

DBusMutex  * GET_DBUS_WSD_VAR_NAME(_dbus_lock_list,dbus_list,g)();

#define _dbus_lock_list (*GET_DBUS_WSD_VAR_NAME(_dbus_lock_list,dbus_list,g)())

DBusMutex  * GET_DBUS_WSD_VAR_NAME(_dbus_lock_shutdown_funcs,dbus_memory,g)();

#define _dbus_lock_shutdown_funcs (*GET_DBUS_WSD_VAR_NAME(_dbus_lock_shutdown_funcs,dbus_memory,g)())

DBusMutex  * GET_DBUS_WSD_VAR_NAME(_dbus_lock_atomic,dbus_sysdeps,g)();

#define _dbus_lock_atomic (*GET_DBUS_WSD_VAR_NAME(_dbus_lock_atomic,dbus_sysdeps,g)())

DBusMutex  * GET_DBUS_WSD_VAR_NAME(_dbus_lock_win_fds,dbus_sysdeps,g)();

#define _dbus_lock_win_fds (*GET_DBUS_WSD_VAR_NAME(_dbus_lock_win_fds,dbus_sysdeps,g)())

DBusMutex  * GET_DBUS_WSD_VAR_NAME(_dbus_lock_sid_atom_cache,dbus_sysdeps,g)();

#define _dbus_lock_sid_atom_cache (*GET_DBUS_WSD_VAR_NAME(_dbus_lock_sid_atom_cache,dbus_sysdeps,g)())

DBusMutex  * GET_DBUS_WSD_VAR_NAME(_dbus_lock_connection_slots,dbus_connection,g)();

#define _dbus_lock_connection_slots (*GET_DBUS_WSD_VAR_NAME(_dbus_lock_connection_slots,dbus_connection,g)())

DBusMutex  * GET_DBUS_WSD_VAR_NAME(_dbus_lock_system_users,dbus_userdb,g)();

#define _dbus_lock_system_users (*GET_DBUS_WSD_VAR_NAME(_dbus_lock_system_users,dbus_userdb,g)())

#endif

static dbus_bool_t

init_locks (void)

{

  int i;

  DBusMutex ***dynamic_global_locks;

#ifndef EMULATOR

DBusMutex **global_locks[] = {

#define LOCK_ADDR(name) (& _dbus_lock_##name)

    LOCK_ADDR (win_fds),

    LOCK_ADDR (sid_atom_cache),

    LOCK_ADDR (list),

    LOCK_ADDR (connection_slots),

    LOCK_ADDR (pending_call_slots),

    LOCK_ADDR (server_slots),

    LOCK_ADDR (message_slots),

    LOCK_ADDR (atomic),

    LOCK_ADDR (bus),

    LOCK_ADDR (bus_datas),

    LOCK_ADDR (shutdown_funcs),

    LOCK_ADDR (system_users),

    LOCK_ADDR (message_cache),

    LOCK_ADDR (shared_connections),

    LOCK_ADDR (machine_uuid)

#undef LOCK_ADDR

  };

#else

DBusMutex **global_locks[15];

#define LOCK_ADDR(name) ((DBusMutex **)& _dbus_lock_##name)

        global_locks[0]=LOCK_ADDR (win_fds);

        global_locks[1]=LOCK_ADDR (sid_atom_cache);

        global_locks[2]=LOCK_ADDR (list);

        global_locks[3]=LOCK_ADDR (connection_slots);

        global_locks[4]=LOCK_ADDR (pending_call_slots);

        global_locks[5]=LOCK_ADDR (server_slots);

        global_locks[6]=LOCK_ADDR (message_slots);

        global_locks[7]=LOCK_ADDR (atomic);

        global_locks[8]=LOCK_ADDR (bus);

        global_locks[9]=LOCK_ADDR (bus_datas);

        global_locks[10]=LOCK_ADDR (shutdown_funcs);

        global_locks[11]=LOCK_ADDR (system_users);

        global_locks[12]=LOCK_ADDR (message_cache);

        global_locks[13]=LOCK_ADDR (shared_connections);

        global_locks[14]=LOCK_ADDR (machine_uuid);