+++ /dev/null
-/*
- * sensord
- *
- * Copyright (c) 2013 Samsung Electronics Co., Ltd.
- *
- * Licensed 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.
- *
- */
-
-#include <pthread.h>
-#include <stdio.h>
-#include <errno.h>
-#include <sys/time.h>
-#include <cbase_lock.h>
-#include <sensor-log-private.h>
-
-using namespace sensor;
-
-cbase_lock::cbase_lock()
-{
- m_history_mutex = PTHREAD_MUTEX_INITIALIZER;
-}
-
-cbase_lock::~cbase_lock()
-{
- pthread_mutex_destroy(&m_history_mutex);
-}
-
-void cbase_lock::lock(lock_type type, const char* expr, const char *module, const char *func, int line)
-{
- int ret = 0;
- char m_curent_info[OWNER_INFO_LEN];
- struct timeval sv;
- unsigned long long lock_waiting_start_time = 0;
- unsigned long long lock_acquired_time = 0;
- unsigned long long waiting_time = 0;
-
- snprintf(m_curent_info, OWNER_INFO_LEN, "%s:%s(%d)", module, func, line);
-
- if (type == LOCK_TYPE_MUTEX)
- ret = try_lock_impl();
- else if (type == LOCK_TYPE_READ)
- ret = try_read_lock_impl();
- else if (type == LOCK_TYPE_WRITE)
- ret = try_write_lock_impl();
-
- if (ret == 0) {
- pthread_mutex_lock(&m_history_mutex);
- snprintf(m_owner_info, OWNER_INFO_LEN, "%s", m_curent_info);
- pthread_mutex_unlock(&m_history_mutex);
- return;
- }
-
- gettimeofday(&sv, NULL);
- lock_waiting_start_time = MICROSECONDS(sv);
-
- pthread_mutex_lock(&m_history_mutex);
- _I("%s is waiting for getting %s(%p) owned in %s",
- m_curent_info, expr, this, m_owner_info);
- pthread_mutex_unlock(&m_history_mutex);
-
- if (type == LOCK_TYPE_MUTEX)
- lock_impl();
- else if (type == LOCK_TYPE_READ)
- read_lock_impl();
- else if (type == LOCK_TYPE_WRITE)
- write_lock_impl();
-
- gettimeofday(&sv, NULL);
- lock_acquired_time = MICROSECONDS(sv);
-
- waiting_time = lock_acquired_time - lock_waiting_start_time;
-
- pthread_mutex_lock(&m_history_mutex);
- _I("%s acquires lock after waiting %lluus, %s(%p) was previously owned in %s",
- m_curent_info, waiting_time, expr, this, m_owner_info);
- snprintf(m_owner_info, OWNER_INFO_LEN, "%s", m_curent_info);
- pthread_mutex_unlock(&m_history_mutex);
-}
-
-void cbase_lock::lock(lock_type type)
-{
- if (type == LOCK_TYPE_MUTEX)
- lock_impl();
- else if (type == LOCK_TYPE_READ)
- read_lock_impl();
- else if (type == LOCK_TYPE_WRITE)
- write_lock_impl();
-}
-
-void cbase_lock::unlock(void)
-{
- unlock_impl();
-}
-
-int cbase_lock::lock_impl(void)
-{
- return 0;
-}
-
-int cbase_lock::read_lock_impl(void)
-{
- return 0;
-}
-
-int cbase_lock::write_lock_impl(void)
-{
- return 0;
-}
-
-int cbase_lock::try_lock_impl(void)
-{
- return 0;
-}
-
-int cbase_lock::try_read_lock_impl(void)
-{
- return 0;
-}
-
-int cbase_lock::try_write_lock_impl(void)
-{
- return 0;
-}
-
-int cbase_lock::unlock_impl(void)
-{
- return 0;
-}
-
-Autolock::Autolock(cbase_lock &m, lock_type type, const char* expr, const char *module, const char *func, int line)
-: m_lock(m)
-{
- m_lock.lock(type, expr, module, func, line);
-}
-
-Autolock::Autolock(cbase_lock &m, lock_type type)
-: m_lock(m)
-{
- m_lock.lock(type);
-}
-
-Autolock::~Autolock()
-{
- m_lock.unlock();
-}
+++ /dev/null
-/*
- * sensord
- *
- * Copyright (c) 2013 Samsung Electronics Co., Ltd.
- *
- * Licensed 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 _CBASE_LOCK_H_
-#define _CBASE_LOCK_H_
-
-#include <pthread.h>
-
-namespace sensor {
-
-enum lock_type {
- LOCK_TYPE_MUTEX,
- LOCK_TYPE_READ,
- LOCK_TYPE_WRITE,
-};
-
-#ifndef MICROSECONDS
-#define MICROSECONDS(tv) ((tv.tv_sec * 1000000ll) + tv.tv_usec)
-#endif
-
-#ifdef _LOCK_DEBUG
-#define AUTOLOCK(x) Autolock x##_autolock((x), LOCK_TYPE_MUTEX, #x, __MODULE__, __func__, __LINE__)
-#define AUTOLOCK_R(x) Autolock x##_autolock_r((x), LOCK_TYPE_READ, #x, __MODULE__, __func__, __LINE__)
-#define AUTOLOCK_W(x) Autolock x##_autolock_w((x), LOCK_TYPE_WRITE, #x, __MODULE__, __func__, __LINE__)
-#define LOCK(x) (x).lock(#x, __MODULE__, __func__, __LINE__)
-#define LOCK_R(x) (x).lock(LOCK_TYPE_READ, #x, __MODULE__, __func__, __LINE__)
-#define LOCK_W(x) (x).lock(LOCK_TYPE_WRITE, #x, __MODULE__, __func__, __LINE__)
-#define UNLOCK(x) (x).unlock()
-#else
-#define AUTOLOCK(x) Autolock x##_autolock((x), LOCK_TYPE_MUTEX)
-#define AUTOLOCK_R(x) Autolock x##_autolock_r((x), LOCK_TYPE_READ)
-#define AUTOLOCK_W(x) Autolock x##_autolock_w((x), LOCK_TYPE_WRITE)
-#define LOCK(x) (x).lock()
-#define LOCK_R(x) (x).lock(LOCK_TYPE_READ)
-#define LOCK_W(x) (x).lock(LOCK_TYPE_WRITE)
-#define UNLOCK(x) (x).unlock()
-#endif
-
-class cbase_lock {
-public:
- cbase_lock();
- virtual ~cbase_lock();
-
- void lock(lock_type type, const char* expr, const char *module, const char *func, int line);
- void lock(lock_type type);
- void unlock(void);
-
-protected:
- virtual int lock_impl(void);
- virtual int read_lock_impl(void);
- virtual int write_lock_impl(void);
-
- virtual int try_lock_impl(void);
- virtual int try_read_lock_impl(void);
- virtual int try_write_lock_impl(void);
-
- virtual int unlock_impl(void);
-private:
- pthread_mutex_t m_history_mutex;
- static const int OWNER_INFO_LEN = 256;
- char m_owner_info[OWNER_INFO_LEN];
-};
-
-class Autolock {
-private:
- cbase_lock& m_lock;
-public:
- Autolock(cbase_lock &m, lock_type type, const char* expr, const char *module, const char *func, int line);
- Autolock(cbase_lock &m, lock_type type);
- ~Autolock();
-};
-}
-
-#endif /* _CBASE_LOCK_H_ */
*
*/
+#include <pthread.h>
+#include <stdio.h>
+#include <sys/time.h>
#include <cmutex.h>
#include <sensor-log-private.h>
void cmutex::lock(void)
{
#ifdef _LOCK_DEBUG
- cbase_lock::lock(LOCK_TYPE_MUTEX, "mutex", __MODULE__, __func__, __LINE__);
+ lock("mutex", __MODULE__, __func__, __LINE__);
#else
- cbase_lock::lock(LOCK_TYPE_MUTEX);
+ lock_impl();
#endif
}
void cmutex::lock(const char* expr, const char *module, const char *func, int line)
{
- cbase_lock::lock(LOCK_TYPE_MUTEX, expr, module, func, line);
+ int ret = 0;
+ char m_curent_info[OWNER_INFO_LEN];
+ struct timeval sv;
+ unsigned long long lock_waiting_start_time = 0;
+ unsigned long long lock_acquired_time = 0;
+ unsigned long long waiting_time = 0;
+
+ snprintf(m_curent_info, OWNER_INFO_LEN, "%s:%s(%d)", module, func, line);
+
+ ret = try_lock_impl();
+
+ if (ret == 0) {
+ pthread_mutex_lock(&m_mutex);
+ snprintf(m_owner_info, OWNER_INFO_LEN, "%s", m_curent_info);
+ pthread_mutex_unlock(&m_mutex);
+ return;
+ }
+
+ gettimeofday(&sv, NULL);
+ lock_waiting_start_time = MICROSECONDS(sv);
+
+ pthread_mutex_lock(&m_mutex);
+ _I("%s is waiting for getting %s(%p) owned in %s",
+ m_curent_info, expr, this, m_owner_info);
+ pthread_mutex_unlock(&m_mutex);
+
+ lock_impl();
+
+ gettimeofday(&sv, NULL);
+ lock_acquired_time = MICROSECONDS(sv);
+
+ waiting_time = lock_acquired_time - lock_waiting_start_time;
+
+ pthread_mutex_lock(&m_mutex);
+ _I("%s acquires lock after waiting %lluus, %s(%p) was previously owned in %s",
+ m_curent_info, waiting_time, expr, this, m_owner_info);
+ snprintf(m_owner_info, OWNER_INFO_LEN, "%s", m_curent_info);
+ pthread_mutex_unlock(&m_mutex);
+}
+
+void cmutex::unlock(void)
+{
+ unlock_impl();
}
int cmutex::try_lock(void)
{
return pthread_mutex_unlock(&m_mutex);
}
+
+Autolock::Autolock(cmutex &m, const char* expr, const char *module, const char *func, int line)
+: m_lock(m)
+{
+ m_lock.lock(expr, module, func, line);
+}
+
+Autolock::Autolock(cmutex &m)
+: m_lock(m)
+{
+ m_lock.lock();
+}
+
+Autolock::~Autolock()
+{
+ m_lock.unlock();
+}
#ifndef _CMUTEX_H_
#define _CMUTEX_H_
-#include "cbase_lock.h"
+#include <pthread.h>
+
namespace sensor {
-class cmutex : public cbase_lock {
+#ifndef MICROSECONDS
+#define MICROSECONDS(tv) ((tv.tv_sec * 1000000ll) + tv.tv_usec)
+#endif
+
+#ifdef _LOCK_DEBUG
+#define AUTOLOCK(x) Autolock x##_autolock((x), #x, __MODULE__, __func__, __LINE__)
+#define LOCK(x) (x).lock(#x, __MODULE__, __func__, __LINE__)
+#define UNLOCK(x) (x).unlock()
+#else
+#define AUTOLOCK(x) Autolock x##_autolock((x))
+#define LOCK(x) (x).lock()
+#define UNLOCK(x) (x).unlock()
+#endif
+
+class cmutex {
public:
cmutex();
virtual ~cmutex();
void lock(void);
void lock(const char* expr, const char *module, const char *func, int line);
+ void unlock(void);
int try_lock(void);
protected:
private:
pthread_mutex_t m_mutex;
+ static const int OWNER_INFO_LEN = 256;
+ char m_owner_info[OWNER_INFO_LEN];
+};
+
+class Autolock {
+private:
+ cmutex& m_lock;
+public:
+ Autolock(cmutex &m, const char* expr, const char *module, const char *func, int line);
+ Autolock(cmutex &m);
+ ~Autolock();
};
}