probe_thread/libdasync.c

   1 /*
   2  *  DA probe
   3  *
   4  * Copyright 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:
   7  *
   8  * Woojin Jung <woojin2.jung@samsung.com>
   9  * Jaewon Lim <jaewon81.lim@samsung.com>
  10  * Juyoung Kim <j0.kim@samsung.com>
  11  *
  12  * This library is free software; you can redistribute it and/or modify it under
  13  * the terms of the GNU Lesser General Public License as published by the
  14  * Free Software Foundation; either version 2.1 of the License, or (at your option)
  15  * any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful, but WITHOUT ANY
  18  * WARRANTY; without even the implied warranty of MERCHANTABILITY or
  19  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
  20  * License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * along with this library; if not, write to the Free Software Foundation, Inc., 51
  24  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  25  *
  26  * Contributors:
  27  * - S-Core Co., Ltd
  28  *
  29  */
  30
  31 #include <pthread.h>
  32 #include <time.h>
  33 #include <errno.h>
  34 #include "daprobe.h"
  35 #include "probeinfo.h"
  36 #include "dahelper.h"
  37 #include "da_sync.h"
  38
  39 #include "binproto.h"
  40
  41 static enum DaOptions _sopt = OPT_THREAD;
  42
  43 int pthread_mutex_init(pthread_mutex_t *mutex,
  44                 const pthread_mutexattr_t *attr) {
  45         static int (*pthread_mutex_initp)(pthread_mutex_t *mutex,
  46                         const pthread_mutexattr_t *attr);
  47
  48         BEFORE_ORIGINAL_SYNC(pthread_mutex_init, LIBPTHREAD);
  49
  50         ret = pthread_mutex_initp(mutex, attr);
  51
  52         AFTER_PACK_ORIGINAL_SYNC(ret, mutex, SYNC_PTHREAD_MUTEX,
  53                         SYNC_API_OTHER, "pp", mutex, attr);
  54
  55         return ret;
  56 }
  57
  58 int pthread_mutex_destroy(pthread_mutex_t *mutex) {
  59         static int (*pthread_mutex_destroyp)(pthread_mutex_t *mutex);
  60
  61         BEFORE_ORIGINAL_SYNC(pthread_mutex_destroy, LIBPTHREAD);
  62
  63         ret = pthread_mutex_destroyp(mutex);
  64
  65         AFTER_PACK_ORIGINAL_SYNC(ret, mutex, SYNC_PTHREAD_MUTEX,
  66                         SYNC_API_OTHER, "p", mutex);
  67
  68         return ret;
  69 }
  70
  71 int real_pthread_mutex_lock(pthread_mutex_t *mutex) {
  72         static int (*pthread_mutex_lockp)(pthread_mutex_t *mutex);
  73
  74         GET_REAL_FUNC(pthread_mutex_lock, LIBPTHREAD);
  75
  76         return pthread_mutex_lockp(mutex);
  77 }
  78
  79 int pthread_mutex_lock(pthread_mutex_t *mutex) {
  80         static int (*pthread_mutex_lockp)(pthread_mutex_t *mutex);
  81
  82         DECLARE_VARIABLE_STANDARD;
  83         GET_REAL_FUNC(pthread_mutex_lock, LIBPTHREAD);
  84
  85         PRE_PROBEBLOCK_BEGIN();
  86
  87         PREPARE_LOCAL_BUF();
  88         PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "p", mutex);
  89         PACK_COMMON_END(0, 0, blockresult);
  90         PACK_SYNC(mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_START);
  91         FLUSH_LOCAL_BUF();
  92
  93         PRE_PROBEBLOCK_END();
  94
  95         ret = pthread_mutex_lockp(mutex);
  96
  97         // send WAIT_END log
  98         newerrno = errno;
  99         if(postBlockBegin(blockresult)) {
 100                 setProbePoint(&probeInfo);
 101
 102                 PREPARE_LOCAL_BUF();
 103                 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "p", mutex);
 104                 PACK_COMMON_END(ret, errno, blockresult);
 105                 PACK_SYNC(mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_END);
 106                 FLUSH_LOCAL_BUF();
 107
 108                 postBlockEnd();
 109         }
 110
 111         return ret;
 112 }
 113
 114 int pthread_mutex_timedlock(pthread_mutex_t *mutex,
 115                 const struct timespec *abs_timeout) {
 116         static int (*pthread_mutex_timedlockp)(pthread_mutex_t *mutex,
 117                         const struct timespec *abs_timeout);
 118
 119         DECLARE_VARIABLE_STANDARD;
 120         GET_REAL_FUNC(pthread_mutex_timedlock, LIBPTHREAD);
 121
 122         PRE_PROBEBLOCK_BEGIN();
 123
 124         PREPARE_LOCAL_BUF();
 125         PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "pp", mutex, abs_timeout);
 126         PACK_COMMON_END(0, 0, blockresult);
 127         PACK_SYNC(mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_START);
 128         FLUSH_LOCAL_BUF();
 129
 130         PRE_PROBEBLOCK_END();
 131
 132         ret = pthread_mutex_timedlockp(mutex, abs_timeout);
 133
 134         // send WAIT_END log
 135         newerrno = errno;
 136         if(postBlockBegin(blockresult)) {
 137                 setProbePoint(&probeInfo);
 138
 139                 PREPARE_LOCAL_BUF();
 140                 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "pp", mutex, abs_timeout);
 141                 PACK_COMMON_END(ret, errno, blockresult);
 142                 PACK_SYNC(mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_END);
 143                 FLUSH_LOCAL_BUF();
 144
 145                 postBlockEnd();
 146         }
 147
 148         return ret;
 149 }
 150
 151 int pthread_mutex_trylock(pthread_mutex_t *mutex) {
 152         static int (*pthread_mutex_trylockp)(pthread_mutex_t *mutex);
 153
 154         BEFORE_ORIGINAL_SYNC(pthread_mutex_trylock, LIBPTHREAD);
 155
 156         ret = pthread_mutex_trylockp(mutex);
 157
 158         AFTER_PACK_ORIGINAL_SYNC(ret, mutex, SYNC_PTHREAD_MUTEX,
 159                         SYNC_API_TRY_ACQUIRE, "p", mutex);
 160
 161         return ret;
 162 }
 163
 164 int real_pthread_mutex_unlock(pthread_mutex_t *mutex) {
 165         static int (*pthread_mutex_unlockp)(pthread_mutex_t *mutex);
 166
 167         GET_REAL_FUNC(pthread_mutex_unlock, LIBPTHREAD);
 168
 169         return pthread_mutex_unlockp(mutex);
 170 }
 171
 172 int pthread_mutex_unlock(pthread_mutex_t *mutex) {
 173         static int (*pthread_mutex_unlockp)(pthread_mutex_t *mutex);
 174
 175         BEFORE_ORIGINAL_SYNC(pthread_mutex_unlock, LIBPTHREAD);
 176
 177         ret = pthread_mutex_unlockp(mutex);
 178
 179         AFTER_PACK_ORIGINAL_SYNC(ret, mutex, SYNC_PTHREAD_MUTEX,
 180                         SYNC_API_RELEASE, "p", mutex);
 181
 182         return ret;
 183 }
 184
 185 int pthread_mutexattr_init(pthread_mutexattr_t *attr) {
 186         static int (*pthread_mutexattr_initp)(pthread_mutexattr_t *attr);
 187
 188         BEFORE_ORIGINAL_SYNC(pthread_mutexattr_init, LIBPTHREAD);
 189
 190         ret = pthread_mutexattr_initp(attr);
 191
 192         AFTER_PACK_ORIGINAL_SYNC(ret, 0, SYNC_PTHREAD_MUTEX,
 193                         SYNC_API_OTHER, "p", attr);
 194
 195         return ret;
 196 }
 197
 198 int pthread_mutexattr_destroy(pthread_mutexattr_t *attr) {
 199         static int (*pthread_mutexattr_destroyp)(pthread_mutexattr_t *attr);
 200
 201         BEFORE_ORIGINAL_SYNC(pthread_mutexattr_destroy, LIBPTHREAD);
 202
 203         ret = pthread_mutexattr_destroyp(attr);
 204
 205         AFTER_PACK_ORIGINAL_SYNC(ret, 0, SYNC_PTHREAD_MUTEX,
 206                         SYNC_API_OTHER, "p", attr);
 207
 208         return ret;
 209 }
 210
 211 int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *attr,
 212                 int *prioceiling) {
 213         static int (*pthread_mutexattr_getprioceilingp)(
 214                         const pthread_mutexattr_t *attr, int *prioceiling);
 215
 216         BEFORE_ORIGINAL_SYNC(pthread_mutexattr_getprioceiling, LIBPTHREAD);
 217
 218         ret = pthread_mutexattr_getprioceilingp(attr, prioceiling);
 219
 220         AFTER_PACK_ORIGINAL_SYNC(ret, 0, SYNC_PTHREAD_MUTEX,
 221                         SYNC_API_OTHER, "pp", attr, prioceiling);
 222
 223         return ret;
 224 }
 225
 226 int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *attr,
 227                 int prioceiling) {
 228         static int (*pthread_mutexattr_setprioceilingp)(
 229                         pthread_mutexattr_t *attr, int prioceiling);
 230
 231         BEFORE_ORIGINAL_SYNC(pthread_mutexattr_setprioceiling, LIBPTHREAD);
 232
 233         ret = pthread_mutexattr_setprioceilingp(attr, prioceiling);
 234
 235         AFTER_PACK_ORIGINAL_SYNC(ret, 0, SYNC_PTHREAD_MUTEX,
 236                         SYNC_API_OTHER, "pd", attr, prioceiling);
 237
 238         return ret;
 239 }
 240
 241 int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *attr,
 242                 int *protocol) {
 243         static int (*pthread_mutexattr_getprotocolp)(
 244                         const pthread_mutexattr_t *attr, int *protocol);
 245
 246         BEFORE_ORIGINAL_SYNC(pthread_mutexattr_getprotocol, LIBPTHREAD);
 247
 248         ret = pthread_mutexattr_getprotocolp(attr, protocol);
 249
 250         AFTER_PACK_ORIGINAL_SYNC(ret, 0, SYNC_PTHREAD_MUTEX,
 251                         SYNC_API_OTHER, "pp", attr, protocol);
 252
 253         return ret;
 254 }
 255
 256 int pthread_mutexattr_setprotocol(pthread_mutexattr_t *attr,
 257                 int protocol) {
 258         static int (*pthread_mutexattr_setprotocolp)(
 259                         pthread_mutexattr_t *attr, int protocol);
 260
 261         BEFORE_ORIGINAL_SYNC(pthread_mutexattr_setprotocol, LIBPTHREAD);
 262
 263         ret = pthread_mutexattr_setprotocolp(attr, protocol);
 264
 265         AFTER_PACK_ORIGINAL_SYNC(ret, 0, SYNC_PTHREAD_MUTEX,
 266                         SYNC_API_OTHER, "pd", attr, protocol);
 267
 268         return ret;
 269 }
 270
 271 int pthread_mutexattr_getpshared(const pthread_mutexattr_t *attr,
 272                 int *pshared) {
 273         static int (*pthread_mutexattr_getpsharedp)(
 274                         const pthread_mutexattr_t *attr, int *pshared);
 275
 276         BEFORE_ORIGINAL_SYNC(pthread_mutexattr_getpshared, LIBPTHREAD);
 277
 278         ret = pthread_mutexattr_getpsharedp(attr, pshared);
 279
 280         AFTER_PACK_ORIGINAL_SYNC(ret, 0, SYNC_PTHREAD_MUTEX,
 281                         SYNC_API_OTHER, "pp", attr, pshared);
 282
 283         return ret;
 284 }
 285
 286 int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr,
 287                 int pshared) {
 288         static int (*pthread_mutexattr_setpsharedp)(
 289                         pthread_mutexattr_t *attr, int pshared);
 290
 291         BEFORE_ORIGINAL_SYNC(pthread_mutexattr_setpshared, LIBPTHREAD);
 292
 293         ret = pthread_mutexattr_setpsharedp(attr, pshared);
 294
 295         AFTER_PACK_ORIGINAL_SYNC(ret, 0, SYNC_PTHREAD_MUTEX,
 296                         SYNC_API_OTHER, "pd", attr, pshared);
 297
 298         return ret;
 299 }
 300
 301 int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *type) {
 302         static int (*pthread_mutexattr_gettypep)(
 303                         const pthread_mutexattr_t *attr, int *type);
 304
 305         BEFORE_ORIGINAL_SYNC(pthread_mutexattr_gettype, LIBPTHREAD);
 306
 307         ret = pthread_mutexattr_gettypep(attr, type);
 308
 309         AFTER_PACK_ORIGINAL_SYNC(ret, 0, SYNC_PTHREAD_MUTEX,
 310                         SYNC_API_OTHER, "pp", attr, type);
 311
 312         return ret;
 313 }
 314
 315 int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type) {
 316         static int (*pthread_mutexattr_settypep)(
 317                         pthread_mutexattr_t *attr, int type);
 318
 319         BEFORE_ORIGINAL_SYNC(pthread_mutexattr_settype, LIBPTHREAD);
 320
 321         ret = pthread_mutexattr_settypep(attr, type);
 322
 323         AFTER_PACK_ORIGINAL_SYNC(ret, 0, SYNC_PTHREAD_MUTEX,
 324                         SYNC_API_OTHER, "pd", attr, type);
 325
 326         return ret;
 327 }
 328
 329 /*
 330 int pthread_mutex_getprioceiling(const pthread_mutex_t *mutex,
 331                 int *prioceiling);
 332 int pthread_mutex_setprioceiling(pthread_mutex_t *mutex,
 333                 int prioceiling, int *old_ceiling);
 334 */
 335
 336 int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr) {
 337         static int (*pthread_cond_initp)(pthread_cond_t *cond,
 338                         const pthread_condattr_t *attr);
 339
 340         BEFORE_ORIGINAL_SYNC(pthread_cond_init, LIBPTHREAD);
 341
 342         ret = pthread_cond_initp(cond, attr);
 343
 344         AFTER_PACK_ORIGINAL_SYNC(ret, cond, SYNC_PTHREAD_COND_VARIABLE,
 345                         SYNC_API_OTHER, "pp", cond, attr);
 346
 347         return ret;
 348 }
 349
 350 int pthread_cond_destroy(pthread_cond_t *cond) {
 351         static int (*pthread_cond_destroyp)(pthread_cond_t *cond);
 352
 353         BEFORE_ORIGINAL_SYNC(pthread_cond_destroy, LIBPTHREAD);
 354
 355         ret = pthread_cond_destroyp(cond);
 356
 357         AFTER_PACK_ORIGINAL_SYNC(ret, cond, SYNC_PTHREAD_COND_VARIABLE,
 358                         SYNC_API_OTHER, "p", cond);
 359
 360         return ret;
 361 }
 362
 363 int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) {
 364         static int (*pthread_cond_waitp)(pthread_cond_t *cond,
 365                         pthread_mutex_t *mutex);
 366
 367         DECLARE_VARIABLE_STANDARD;
 368         GET_REAL_FUNC(pthread_cond_wait, LIBPTHREAD);
 369
 370         PRE_PROBEBLOCK_BEGIN();
 371         // send WAIT_START log
 372
 373         PREPARE_LOCAL_BUF();
 374         PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "pp", cond, mutex);
 375         PACK_COMMON_END(0, 0, blockresult);
 376         PACK_SYNC(cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_START);
 377         FLUSH_LOCAL_BUF();
 378
 379         PRE_PROBEBLOCK_END();
 380
 381         ret = pthread_cond_waitp(cond, mutex);
 382
 383         // send WAIT_END log
 384         newerrno = errno;
 385         if(postBlockBegin(blockresult)) {
 386                 setProbePoint(&probeInfo);
 387
 388                 PREPARE_LOCAL_BUF();
 389                 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "pp", cond, mutex);
 390                 PACK_COMMON_END(ret, errno, blockresult);
 391                 PACK_SYNC(cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_END);
 392                 FLUSH_LOCAL_BUF();
 393
 394                 postBlockEnd();
 395         }
 396
 397         return ret;
 398 }
 399
 400 int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
 401                 const struct timespec *abstime) {
 402         static int (*pthread_cond_timedwaitp)(pthread_cond_t *cond,
 403                                 pthread_mutex_t *mutex, const struct timespec *abstime);
 404
 405         DECLARE_VARIABLE_STANDARD;
 406         GET_REAL_FUNC(pthread_cond_timedwait, LIBPTHREAD);
 407
 408         PRE_PROBEBLOCK_BEGIN();
 409         // send WAIT_START log
 410
 411         PREPARE_LOCAL_BUF();
 412         PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "ppp", cond, mutex, abstime);
 413         PACK_COMMON_END(0, 0, blockresult);
 414         PACK_SYNC(cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_START);
 415         FLUSH_LOCAL_BUF();
 416
 417         PRE_PROBEBLOCK_END();
 418
 419         ret = pthread_cond_timedwaitp(cond, mutex, abstime);
 420
 421         // send WAIT_END log
 422         newerrno = errno;
 423         if(postBlockBegin(blockresult)) {
 424                 setProbePoint(&probeInfo);
 425
 426                 PREPARE_LOCAL_BUF();
 427                 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "ppp", cond, mutex, abstime);
 428                 PACK_COMMON_END(ret, errno, blockresult);
 429                 PACK_SYNC(cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_END);
 430                 FLUSH_LOCAL_BUF();
 431
 432                 postBlockEnd();
 433         }
 434
 435         return ret;
 436 }
 437
 438 int pthread_cond_signal(pthread_cond_t *cond) {
 439         static int (*pthread_cond_signalp)(pthread_cond_t *cond);
 440
 441         BEFORE_ORIGINAL_SYNC(pthread_cond_signal, LIBPTHREAD);
 442
 443         ret = pthread_cond_signalp(cond);
 444
 445         AFTER_PACK_ORIGINAL_SYNC(ret, cond, SYNC_PTHREAD_COND_VARIABLE,
 446                         SYNC_API_NOTIFY, "p", cond);
 447
 448         return ret;
 449 }
 450
 451 int pthread_cond_broadcast(pthread_cond_t *cond) {
 452         static int (*pthread_cond_broadcastp)(pthread_cond_t *cond);
 453
 454         BEFORE_ORIGINAL_SYNC(pthread_cond_broadcast, LIBPTHREAD);
 455
 456         ret = pthread_cond_broadcastp(cond);
 457
 458         AFTER_PACK_ORIGINAL_SYNC(ret, cond, SYNC_PTHREAD_COND_VARIABLE,
 459                         SYNC_API_NOTIFY_ALL, "p", cond);
 460
 461         return ret;
 462 }
 463
 464 /*
 465 int pthread_condattr_init(pthread_condattr_t *attr);
 466 int pthread_condattr_destroy(pthread_condattr_t *attr);
 467 int pthread_condattr_getclock(const pthread_condattr_t *attr,
 468                 clockid_t *clock_id);
 469 int pthread_condattr_setclock(pthread_condattr_t *attr,
 470                 clockid_t clock_id);
 471 int pthread_condattr_getpshared(const pthread_condattr_t *attr, int *pshared);
 472 int pthread_condattr_setpshared(pthread_condattr_t *attr, int pshared);
 473 */
 474
 475 /*
 476 int pthread_rwlock_init(pthread_rwlock_t *rwlock,
 477                 const pthread_rwlockattr_t *attr);
 478 int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
 479 int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
 480 int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
 481 int pthread_rwlock_timedrdlock(pthread_rwlock_t *rwlock,
 482                 const struct timespec *abs_timeout);
 483 int pthread_rwlock_timedwrlock(pthread_rwlock_t *rwlock,
 484                 const struct timespec *abs_timeout);
 485 int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
 486 int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
 487 int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
 488 int pthread_rwlockattr_init(pthread_rwlockattr_t *attr);
 489 int pthread_rwlockattr_destroy(pthread_rwlockattr_t *attr);
 490 int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *attr,
 491                 int *pshared);
 492 int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *attr,
 493                 int pshared);
 494
 495 int pthread_spin_init(pthread_spinlock_t *lock, int pshared);
 496 int pthread_spin_destroy(pthread_spinlock_t *lock);
 497 int pthread_spin_lock(pthread_spinlock_t *lock);
 498 int pthread_spin_trylock(pthread_spinlock_t *lock);
 499 int pthread_spin_unlock(pthread_spinlock_t *lock);
 500
 501 int pthread_barrier_init(pthread_barrier_t *barrier,
 502                 const pthread_barrierattr_t *attr, unsigned int count);
 503 int pthread_barrier_destroy(pthread_barrier_t *barrier);
 504 int pthread_barrier_wait(pthread_barrier_t *barrier);
 505 int pthread_barrierattr_init(pthread_barrierattr_t *attr);
 506 int pthread_barrierattr_destroy(pthread_barrierattr_t *attr);
 507 int pthread_barrierattr_getpshared(const pthread_barrierattr_t *attr,
 508                 int *pshared);
 509 int pthread_barrierattr_setpshared(pthread_barrierattr_t,
 510                 int pshared);
 511 */
 512