One Level Up Top Level

src/os/unix/ngx_pthread_thread.c - nginx-1.7.10

Global variables defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>


  12. ‌static ngx_uint_t   nthreads;
  13. ‌static ngx_uint_t   max_threads;


  16. ‌static pthread_attr_t  thr_attr;


  19. ngx_err_t
  20. ‌ngx_create_thread(ngx_tid_t *tid, ngx_thread_value_t (*func)(void *arg),
  21.     void *arg, ngx_log_t *log)
  22. {
  23.     int  err;

  25.     if (nthreads >= max_threads) {
  26.         ngx_log_error(NGX_LOG_CRIT, log, 0,
  27.                       "no more than %ui threads can be created", max_threads);
  28.         return NGX_ERROR;
  29.     }

  31.     err = pthread_create(tid, &thr_attr, func, arg);

  33.     if (err != 0) {
  34.         ngx_log_error(NGX_LOG_ALERT, log, err, "pthread_create() failed");
  35.         return err;
  36.     }

  38.     ngx_log_debug1(NGX_LOG_DEBUG_CORE, log, 0,
  39.                    "thread is created: " NGX_TID_T_FMT, *tid);

  41.     nthreads++;

  43.     return err;
  44. }


  47. ngx_int_t
  48. ‌ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle)
  49. {
  50.     int  err;

  52.     max_threads = n;

  54.     err = pthread_attr_init(&thr_attr);

  56.     if (err != 0) {
  57.         ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
  58.                       "pthread_attr_init() failed");
  59.         return NGX_ERROR;
  60.     }

  62.     err = pthread_attr_setstacksize(&thr_attr, size);

  64.     if (err != 0) {
  65.         ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
  66.                       "pthread_attr_setstacksize() failed");
  67.         return NGX_ERROR;
  68.     }

  70.     ngx_threaded = 1;

  72.     return NGX_OK;
  73. }


  76. ngx_mutex_t *
  77. ‌ngx_mutex_init(ngx_log_t *log, ngx_uint_t flags)
  78. {
  79.     int           err;
  80.     ngx_mutex_t  *m;

  82.     m = ngx_alloc(sizeof(ngx_mutex_t), log);
  83.     if (m == NULL) {
  84.         return NULL;
  85.     }

  87.     m->log = log;

  89.     err = pthread_mutex_init(&m->mutex, NULL);

  91.     if (err != 0) {
  92.         ngx_log_error(NGX_LOG_ALERT, m->log, err,
  93.                       "pthread_mutex_init() failed");
  94.         return NULL;
  95.     }

  97.     return m;
  98. }


  101. void
  102. ‌ngx_mutex_destroy(ngx_mutex_t *m)
  103. {
  104.     int  err;

  106.     err = pthread_mutex_destroy(&m->mutex);

  108.     if (err != 0) {
  109.         ngx_log_error(NGX_LOG_ALERT, m->log, err,
  110.                       "pthread_mutex_destroy(%p) failed", m);
  111.     }

  113.     ngx_free(m);
  114. }


  117. void
  118. ‌ngx_mutex_lock(ngx_mutex_t *m)
  119. {
  120.     int  err;

  122.     if (!ngx_threaded) {
  123.         return;
  124.     }

  126.     ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "lock mutex %p", m);

  128.     err = pthread_mutex_lock(&m->mutex);

  130.     if (err != 0) {
  131.         ngx_log_error(NGX_LOG_ALERT, m->log, err,
  132.                       "pthread_mutex_lock(%p) failed", m);
  133.         ngx_abort();
  134.     }

  136.     ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "mutex %p is locked", m);

  138.     return;
  139. }


  142. ngx_int_t
  143. ‌ngx_mutex_trylock(ngx_mutex_t *m)
  144. {
  145.     int  err;

  147.     if (!ngx_threaded) {
  148.         return NGX_OK;
  149.     }

  151.     ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "try lock mutex %p", m);

  153.     err = pthread_mutex_trylock(&m->mutex);

  155.     if (err == NGX_EBUSY) {
  156.         return NGX_AGAIN;
  157.     }

  159.     if (err != 0) {
  160.         ngx_log_error(NGX_LOG_ALERT, m->log, err,
  161.                       "pthread_mutex_trylock(%p) failed", m);
  162.         ngx_abort();
  163.     }

  165.     ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "mutex %p is locked", m);

  167.     return NGX_OK;
  168. }


  171. void
  172. ‌ngx_mutex_unlock(ngx_mutex_t *m)
  173. {
  174.     int  err;

  176.     if (!ngx_threaded) {
  177.         return;
  178.     }

  180.     ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "unlock mutex %p", m);

  182.     err = pthread_mutex_unlock(&m->mutex);

  184.     if (err != 0) {
  185.         ngx_log_error(NGX_LOG_ALERT, m->log, err,
  186.                       "pthread_mutex_unlock(%p) failed", m);
  187.         ngx_abort();
  188.     }

  190.     ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "mutex %p is unlocked", m);

  192.     return;
  193. }


  196. ngx_cond_t *
  197. ‌ngx_cond_init(ngx_log_t *log)
  198. {
  199.     int          err;
  200.     ngx_cond_t  *cv;

  202.     cv = ngx_alloc(sizeof(ngx_cond_t), log);
  203.     if (cv == NULL) {
  204.         return NULL;
  205.     }

  207.     cv->log = log;

  209.     err = pthread_cond_init(&cv->cond, NULL);

  211.     if (err != 0) {
  212.         ngx_log_error(NGX_LOG_ALERT, cv->log, err,
  213.                       "pthread_cond_init() failed");
  214.         return NULL;
  215.     }

  217.     return cv;
  218. }


  221. void
  222. ‌ngx_cond_destroy(ngx_cond_t *cv)
  223. {
  224.     int  err;

  226.     err = pthread_cond_destroy(&cv->cond);

  228.     if (err != 0) {
  229.         ngx_log_error(NGX_LOG_ALERT, cv->log, err,
  230.                       "pthread_cond_destroy(%p) failed", cv);
  231.     }

  233.     ngx_free(cv);
  234. }


  237. ngx_int_t
  238. ‌ngx_cond_wait(ngx_cond_t *cv, ngx_mutex_t *m)
  239. {
  240.     int  err;

  242.     ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->log, 0, "cv %p wait", cv);

  244.     err = pthread_cond_wait(&cv->cond, &m->mutex);

  246.     if (err != 0) {
  247.         ngx_log_error(NGX_LOG_ALERT, cv->log, err,
  248.                       "pthread_cond_wait(%p) failed", cv);
  249.         return NGX_ERROR;
  250.     }

  252.     ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->log, 0, "cv %p is waked up", cv);

  254.     ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "mutex %p is locked", m);

  256.     return NGX_OK;
  257. }


  260. ngx_int_t
  261. ‌ngx_cond_signal(ngx_cond_t *cv)
  262. {
  263.     int  err;

  265.     ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->log, 0, "cv %p to signal", cv);

  267.     err = pthread_cond_signal(&cv->cond);

  269.     if (err != 0) {
  270.         ngx_log_error(NGX_LOG_ALERT, cv->log, err,
  271.                       "pthread_cond_signal(%p) failed", cv);
  272.         return NGX_ERROR;
  273.     }

  275.     ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->log, 0, "cv %p is signaled", cv);

  277.     return NGX_OK;
  278. }

One Level Up Top Level