开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
thr_alarm.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：28k
源码类别：

MySQL数据库

开发平台：

Visual C++

thr_alarm.c：源码内容
  1. /* Copyright (C) 2000 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. /* To avoid problems with alarms in debug code, we disable DBUG here */
  18. #undef DBUG_OFF
  19. #define DBUG_OFF
  20. #include <my_global.h>
  22. #if defined(THREAD) && !defined(DONT_USE_THR_ALARM)
  23. #include <errno.h>
  24. #include <my_pthread.h>
  25. #include <signal.h>
  26. #include <my_sys.h>
  27. #include <m_string.h>
  28. #include <queues.h>
  29. #include "thr_alarm.h"
  31. #ifdef HAVE_SYS_SELECT_H
  32. #include <sys/select.h> /* AIX needs this for fd_set */
  33. #endif
  35. #ifndef ETIME
  36. #define ETIME ETIMEDOUT
  37. #endif
  39. static int alarm_aborted=1; /* No alarm thread */
  40. my_bool thr_alarm_inited= 0;
  41. volatile my_bool alarm_thread_running= 0;
  43. static sig_handler process_alarm_part2(int sig);
  45. #if !defined(__WIN__) && !defined(__EMX__) && !defined(OS2)
  47. static pthread_mutex_t LOCK_alarm;
  48. static pthread_cond_t COND_alarm;
  49. static sigset_t full_signal_set;
  50. static QUEUE alarm_queue;
  51. static uint max_used_alarms=0;
  52. pthread_t alarm_thread;
  54. #ifdef USE_ALARM_THREAD
  55. static void *alarm_handler(void *arg);
  56. #define reschedule_alarms() pthread_cond_signal(&COND_alarm)
  57. #else
  58. #define reschedule_alarms() pthread_kill(alarm_thread,THR_SERVER_ALARM)
  59. #endif
  61. #if THR_CLIENT_ALARM != SIGALRM || defined(USE_ALARM_THREAD)
  62. static sig_handler thread_alarm(int sig __attribute__((unused)));
  63. #endif
  65. static int compare_ulong(void *not_used __attribute__((unused)),
  66.  byte *a_ptr,byte* b_ptr)
  67. {
  68.   ulong a=*((ulong*) a_ptr),b= *((ulong*) b_ptr);
  69.   return (a < b) ? -1  : (a == b) ? 0 : 1;
  70. }
  72. void init_thr_alarm(uint max_alarms)
  73. {
  74.   sigset_t s;
  75.   DBUG_ENTER("init_thr_alarm");
  76.   alarm_aborted=0;
  77.   init_queue(&alarm_queue,max_alarms+1,offsetof(ALARM,expire_time),0,
  78.      compare_ulong,NullS);
  79.   sigfillset(&full_signal_set); /* Neaded to block signals */
  80.   pthread_mutex_init(&LOCK_alarm,MY_MUTEX_INIT_FAST);
  81.   pthread_cond_init(&COND_alarm,NULL);
  82. #if THR_CLIENT_ALARM != SIGALRM || defined(USE_ALARM_THREAD)
  83.   my_sigset(THR_CLIENT_ALARM,thread_alarm);
  84. #endif
  85.   sigemptyset(&s);
  86.   sigaddset(&s, THR_SERVER_ALARM);
  87.   alarm_thread=pthread_self();
  88. #if defined(USE_ALARM_THREAD)
  89.   {
  90.     pthread_attr_t thr_attr;
  91.     pthread_attr_init(&thr_attr);
  92.     pthread_attr_setscope(&thr_attr,PTHREAD_SCOPE_PROCESS);
  93.     pthread_attr_setdetachstate(&thr_attr,PTHREAD_CREATE_DETACHED);
  94.     pthread_attr_setstacksize(&thr_attr,8196);
  96.     my_pthread_attr_setprio(&thr_attr,100); /* Very high priority */
  97.     VOID(pthread_create(&alarm_thread,&thr_attr,alarm_handler,NULL));
  98.     VOID(pthread_attr_destroy(&thr_attr));
  99.   }
  100. #elif defined(USE_ONE_SIGNAL_HAND)
  101.   pthread_sigmask(SIG_BLOCK, &s, NULL); /* used with sigwait() */
  102. #if THR_SERVER_ALARM == THR_CLIENT_ALARM
  103.   my_sigset(THR_CLIENT_ALARM,process_alarm); /* Linuxthreads */
  104.   pthread_sigmask(SIG_UNBLOCK, &s, NULL);
  105. #endif
  106. #else
  107.   my_sigset(THR_SERVER_ALARM, process_alarm);
  108.   pthread_sigmask(SIG_UNBLOCK, &s, NULL);
  109. #endif
  110.   DBUG_VOID_RETURN;
  111. }
  114. void resize_thr_alarm(uint max_alarms)
  115. {
  116.   pthread_mutex_lock(&LOCK_alarm);
  117.   /*
  118.     It's ok not to shrink the queue as there may be more pending alarms than
  119.     than max_alarms
  120.   */
  121.   if (alarm_queue.elements < max_alarms)
  122.     resize_queue(&alarm_queue,max_alarms+1);
  123.   pthread_mutex_unlock(&LOCK_alarm);
  124. }
  127. /*
  128.   Request alarm after sec seconds.
  130.   SYNOPSIS
  131.     thr_alarm()
  132.     alrm Pointer to alarm detection
  133.     alarm_data Structure to store in alarm queue
  135.   NOTES
  136.     This function can't be called from the alarm-handling thread.
  138.   RETURN VALUES
  139.     0 ok
  140.     1 If no more alarms are allowed (aborted by process)
  142.     Stores in first argument a pointer to a non-zero int which is set to 0
  143.     when the alarm has been given
  144. */
  146. my_bool thr_alarm(thr_alarm_t *alrm, uint sec, ALARM *alarm_data)
  147. {
  148.   ulong now;
  149.   sigset_t old_mask;
  150.   my_bool reschedule;
  151.   DBUG_ENTER("thr_alarm");
  152.   DBUG_PRINT("enter",("thread: %s  sec: %d",my_thread_name(),sec));
  154.   now=(ulong) time((time_t*) 0);
  155.   pthread_sigmask(SIG_BLOCK,&full_signal_set,&old_mask);
  156.   pthread_mutex_lock(&LOCK_alarm); /* Lock from threads & alarms */
  157.   if (alarm_aborted > 0)
  158.   { /* No signal thread */
  159.     DBUG_PRINT("info", ("alarm aborted"));
  160.     *alrm= 0; /* No alarm */
  161.     pthread_mutex_unlock(&LOCK_alarm);
  162.     pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
  163.     DBUG_RETURN(1);
  164.   }
  165.   if (alarm_aborted < 0)
  166.     sec= 1; /* Abort mode */
  168.   if (alarm_queue.elements >= max_used_alarms)
  169.   {
  170.     if (alarm_queue.elements == alarm_queue.max_elements)
  171.     {
  172.       DBUG_PRINT("info", ("alarm queue full"));
  173.       fprintf(stderr,"Warning: thr_alarm queue is fulln");
  174.       *alrm= 0; /* No alarm */
  175.       pthread_mutex_unlock(&LOCK_alarm);
  176.       pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
  177.       DBUG_RETURN(1);
  178.     }
  179.     max_used_alarms=alarm_queue.elements+1;
  180.   }
  181.   reschedule= (!alarm_queue.elements ||
  182.       (int) (((ALARM*) queue_top(&alarm_queue))->expire_time - now) >
  183.       (int) sec);
  184.   if (!alarm_data)
  185.   {
  186.     if (!(alarm_data=(ALARM*) my_malloc(sizeof(ALARM),MYF(MY_WME))))
  187.     {
  188.       DBUG_PRINT("info", ("failed my_malloc()"));
  189.       *alrm= 0; /* No alarm */
  190.       pthread_mutex_unlock(&LOCK_alarm);
  191.       pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
  192.       DBUG_RETURN(1);
  193.     }
  194.     alarm_data->malloced=1;
  195.   }
  196.   else
  197.     alarm_data->malloced=0;
  198.   alarm_data->expire_time=now+sec;
  199.   alarm_data->alarmed=0;
  200.   alarm_data->thread=pthread_self();
  201.   queue_insert(&alarm_queue,(byte*) alarm_data);
  203.   /* Reschedule alarm if the current one has more than sec left */
  204.   if (reschedule)
  205.   {
  206.     DBUG_PRINT("info", ("reschedule"));
  207.     if (pthread_equal(pthread_self(),alarm_thread))
  208.       alarm(sec); /* purecov: inspected */
  209.     else
  210.       reschedule_alarms(); /* Reschedule alarms */
  211.   }
  212.   pthread_mutex_unlock(&LOCK_alarm);
  213.   pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
  214.   (*alrm)= &alarm_data->alarmed;
  215.   DBUG_RETURN(0);
  216. }
  219. /*
  220.   Remove alarm from list of alarms
  221. */
  223. void thr_end_alarm(thr_alarm_t *alarmed)
  224. {
  225.   ALARM *alarm_data;
  226.   sigset_t old_mask;
  227.   uint i, found=0;
  228.   DBUG_ENTER("thr_end_alarm");
  230.   pthread_sigmask(SIG_BLOCK,&full_signal_set,&old_mask);
  231.   pthread_mutex_lock(&LOCK_alarm);
  233.   alarm_data= (ALARM*) ((byte*) *alarmed - offsetof(ALARM,alarmed));
  234.   for (i=0 ; i < alarm_queue.elements ; i++)
  235.   {
  236.     if ((ALARM*) queue_element(&alarm_queue,i) == alarm_data)
  237.     {
  238.       queue_remove(&alarm_queue,i),MYF(0);
  239.       if (alarm_data->malloced)
  240. my_free((gptr) alarm_data,MYF(0));
  241.       found++;
  242. #ifdef DBUG_OFF
  243.       break;
  244. #endif
  245.     }
  246.   }
  247.   DBUG_ASSERT(!*alarmed || found == 1);
  248.   if (!found)
  249.   {
  250.     if (*alarmed)
  251.       fprintf(stderr,"Warning: Didn't find alarm 0x%lx in queue of %d alarmsn",
  252.       (long) *alarmed, alarm_queue.elements);
  253.     DBUG_PRINT("warning",("Didn't find alarm 0x%lx in queuen",
  254.   (long) *alarmed));
  255.   }
  256.   pthread_mutex_unlock(&LOCK_alarm);
  257.   pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
  258.   DBUG_VOID_RETURN;
  259. }
  261. /*
  262.   Come here when some alarm in queue is due.
  263.   Mark all alarms with are finnished in list.
  264.   Shedule alarms to be sent again after 1-10 sec (many alarms at once)
  265.   If alarm_aborted is set then all alarms are given and resent
  266.   every second.
  267. */
  269. sig_handler process_alarm(int sig __attribute__((unused)))
  270. {
  271.   sigset_t old_mask;
  272. /*
  273.   This must be first as we can't call DBUG inside an alarm for a normal thread
  274. */
  276. #if THR_SERVER_ALARM == THR_CLIENT_ALARM
  277.   if (!pthread_equal(pthread_self(),alarm_thread))
  278.   {
  279. #if defined(MAIN) && !defined(__bsdi__)
  280.     printf("thread_alarmn"); fflush(stdout);
  281. #endif
  282. #ifdef DONT_REMEMBER_SIGNAL
  283.     my_sigset(THR_CLIENT_ALARM,process_alarm); /* int. thread system calls */
  284. #endif
  285.     return;
  286.   }
  287. #endif
  289.   /*
  290.     We have to do do the handling of the alarm in a sub function,
  291.     because otherwise we would get problems with two threads calling
  292.     DBUG_... functions at the same time (as two threads may call
  293.     process_alarm() at the same time
  294.   */
  296. #ifndef USE_ALARM_THREAD
  297.   pthread_sigmask(SIG_SETMASK,&full_signal_set,&old_mask);
  298.   pthread_mutex_lock(&LOCK_alarm);
  299. #endif
  300.   process_alarm_part2(sig);
  301. #ifndef USE_ALARM_THREAD
  302. #if defined(DONT_REMEMBER_SIGNAL) && !defined(USE_ONE_SIGNAL_HAND)
  303.   my_sigset(THR_SERVER_ALARM,process_alarm);
  304. #endif
  305.   pthread_mutex_unlock(&LOCK_alarm);
  306.   pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
  307. #endif
  308.   return;
  309. }
  312. static sig_handler process_alarm_part2(int sig __attribute__((unused)))
  313. {
  314.   ALARM *alarm_data;
  315.   DBUG_ENTER("process_alarm");
  316.   DBUG_PRINT("info",("sig: %d  active alarms: %d",sig,alarm_queue.elements));
  318. #if defined(MAIN) && !defined(__bsdi__)
  319.   printf("process_alarmn"); fflush(stdout);
  320. #endif
  321.   if (alarm_queue.elements)
  322.   {
  323.     if (alarm_aborted)
  324.     {
  325.       uint i;
  326.       for (i=0 ; i < alarm_queue.elements ;)
  327.       {
  328. alarm_data=(ALARM*) queue_element(&alarm_queue,i);
  329. alarm_data->alarmed=1; /* Info to thread */
  330. if (pthread_equal(alarm_data->thread,alarm_thread) ||
  331.     pthread_kill(alarm_data->thread, THR_CLIENT_ALARM))
  332. {
  333. #ifdef MAIN
  334.   printf("Warning: pthread_kill couldn't find thread!!!n");
  335. #endif
  336.   queue_remove(&alarm_queue,i); /* No thread. Remove alarm */
  337. }
  338. else
  339.   i++; /* Signal next thread */
  340.       }
  341. #ifndef USE_ALARM_THREAD
  342.       if (alarm_queue.elements)
  343. alarm(1); /* Signal soon again */
  344. #endif
  345.     }
  346.     else
  347.     {
  348.       ulong now=(ulong) time((time_t*) 0);
  349.       ulong next=now+10-(now%10);
  350.       while ((alarm_data=(ALARM*) queue_top(&alarm_queue))->expire_time <= now)
  351.       {
  352. alarm_data->alarmed=1; /* Info to thread */
  353. DBUG_PRINT("info",("sending signal to waiting thread"));
  354. if (pthread_equal(alarm_data->thread,alarm_thread) ||
  355.     pthread_kill(alarm_data->thread, THR_CLIENT_ALARM))
  356. {
  357. #ifdef MAIN
  358.   printf("Warning: pthread_kill couldn't find thread!!!n");
  359. #endif
  360.   queue_remove(&alarm_queue,0); /* No thread. Remove alarm */
  361.   if (!alarm_queue.elements)
  362.     break;
  363. }
  364. else
  365. {
  366.   alarm_data->expire_time=next;
  367.   queue_replaced(&alarm_queue);
  368. }
  369.       }
  370. #ifndef USE_ALARM_THREAD
  371.       if (alarm_queue.elements)
  372.       {
  373. #ifdef __bsdi__
  374. alarm(0); /* Remove old alarm */
  375. #endif
  376. alarm((uint) (alarm_data->expire_time-now));
  377.       }
  378. #endif
  379.     }
  380.   }
  381.   DBUG_VOID_RETURN;
  382. }
  385. /*
  386.   Schedule all alarms now and optionally free all structures
  388.   SYNPOSIS
  389.     end_thr_alarm()
  390.       free_structures Set to 1 if we should free memory used for
  391. the alarm queue.
  392. When we call this we should KNOW that there
  393. is no active alarms
  394.   IMPLEMENTATION
  395.     Set alarm_abort to -1 which will change the behavior of alarms as follows:
  396.     - All old alarms will be rescheduled at once
  397.     - All new alarms will be rescheduled to one second
  398. */
  400. void end_thr_alarm(my_bool free_structures)
  401. {
  402.   DBUG_ENTER("end_thr_alarm");
  403.   if (alarm_aborted != 1) /* If memory not freed */
  404.   {    
  405.     pthread_mutex_lock(&LOCK_alarm);
  406.     DBUG_PRINT("info",("Resheduling %d waiting alarms",alarm_queue.elements));
  407.     alarm_aborted= -1; /* mark aborted */
  408.     if (alarm_queue.elements || (alarm_thread_running && free_structures))
  409.     {
  410.       if (pthread_equal(pthread_self(),alarm_thread))
  411. alarm(1); /* Shut down everything soon */
  412.       else
  413. reschedule_alarms();
  414.     }
  415.     if (free_structures)
  416.     {
  417.       struct timespec abstime;
  418.       /*
  419. The following test is just for safety, the caller should not
  420. depend on this
  421.       */
  422.       DBUG_ASSERT(!alarm_queue.elements);
  423.       /* Wait until alarm thread dies */
  425.       set_timespec(abstime, 10); /* Wait up to 10 seconds */
  426.       while (alarm_thread_running)
  427.       {
  428. int error= pthread_cond_timedwait(&COND_alarm, &LOCK_alarm, &abstime);
  429. if (error == ETIME || error == ETIMEDOUT)
  430.   break; /* Don't wait forever */
  431.       }
  432.       if (!alarm_queue.elements)
  433.       {
  434. delete_queue(&alarm_queue);
  435. alarm_aborted= 1;
  436. pthread_mutex_unlock(&LOCK_alarm);
  437. if (!alarm_thread_running) /* Safety */
  438. {
  439.   pthread_mutex_destroy(&LOCK_alarm);
  440.   pthread_cond_destroy(&COND_alarm);
  441. }
  442.       }
  443.     }
  444.     else
  445.       pthread_mutex_unlock(&LOCK_alarm);
  446.   }
  447.   DBUG_VOID_RETURN;
  448. }
  451. /*
  452.   Remove another thread from the alarm
  453. */
  455. void thr_alarm_kill(pthread_t thread_id)
  456. {
  457.   uint i;
  458.   if (alarm_aborted)
  459.     return;
  460.   pthread_mutex_lock(&LOCK_alarm);
  461.   for (i=0 ; i < alarm_queue.elements ; i++)
  462.   {
  463.     if (pthread_equal(((ALARM*) queue_element(&alarm_queue,i))->thread,
  464.       thread_id))
  465.     {
  466.       ALARM *tmp=(ALARM*) queue_remove(&alarm_queue,i);
  467.       tmp->expire_time=0;
  468.       queue_insert(&alarm_queue,(byte*) tmp);
  469.       reschedule_alarms();
  470.       break;
  471.     }
  472.   }
  473.   pthread_mutex_unlock(&LOCK_alarm);
  474. }
  477. void thr_alarm_info(ALARM_INFO *info)
  478. {
  479.   pthread_mutex_lock(&LOCK_alarm);
  480.   info->next_alarm_time= 0;
  481.   info->max_used_alarms= max_used_alarms;
  482.   if ((info->active_alarms=  alarm_queue.elements))
  483.   {
  484.     ulong now=(ulong) time((time_t*) 0);
  485.     long time_diff;
  486.     ALARM *alarm_data= (ALARM*) queue_top(&alarm_queue);
  487.     time_diff= (long) (alarm_data->expire_time - now);
  488.     info->next_alarm_time= (ulong) (time_diff < 0 ? 0 : time_diff);
  489.   }
  490.   pthread_mutex_unlock(&LOCK_alarm);
  491. }
  493. /*
  494.   This is here for thread to get interruptet from read/write/fcntl
  495.   ARGSUSED
  496. */
  498. #if THR_CLIENT_ALARM != SIGALRM || defined(USE_ALARM_THREAD)
  499. static sig_handler thread_alarm(int sig)
  500. {
  501. #ifdef MAIN
  502.   printf("thread_alarmn"); fflush(stdout);
  503. #endif
  504. #ifdef DONT_REMEMBER_SIGNAL
  505.   my_sigset(sig,thread_alarm); /* int. thread system calls */
  506. #endif
  507. }
  508. #endif
  511. #ifdef HAVE_TIMESPEC_TS_SEC
  512. #define tv_sec ts_sec
  513. #define tv_nsec ts_nsec
  514. #endif
  516. /* set up a alarm thread with uses 'sleep' to sleep between alarms */
  518. #ifdef USE_ALARM_THREAD
  519. static void *alarm_handler(void *arg __attribute__((unused)))
  520. {
  521.   int error;
  522.   struct timespec abstime;
  523. #ifdef MAIN
  524.   puts("Starting alarm thread");
  525. #endif
  526.   my_thread_init();
  527.   alarm_thread_running= 1;
  528.   pthread_mutex_lock(&LOCK_alarm);
  529.   for (;;)
  530.   {
  531.     if (alarm_queue.elements)
  532.     {
  533.       ulong sleep_time,now=time((time_t*) 0);
  534.       if (alarm_aborted)
  535. sleep_time=now+1;
  536.       else
  537. sleep_time= ((ALARM*) queue_top(&alarm_queue))->expire_time;
  538.       if (sleep_time > now)
  539.       {
  540. abstime.tv_sec=sleep_time;
  541. abstime.tv_nsec=0;
  542. if ((error=pthread_cond_timedwait(&COND_alarm,&LOCK_alarm,&abstime)) &&
  543.     error != ETIME && error != ETIMEDOUT)
  544. {
  545. #ifdef MAIN
  546.   printf("Got error: %d from ptread_cond_timedwait (errno: %d)n",
  547.  error,errno);
  548. #endif
  549. }
  550.       }
  551.     }
  552.     else if (alarm_aborted == -1)
  553.       break;
  554.     else if ((error=pthread_cond_wait(&COND_alarm,&LOCK_alarm)))
  555.     {
  556. #ifdef MAIN
  557.       printf("Got error: %d from ptread_cond_wait (errno: %d)n",
  558.      error,errno);
  559. #endif
  560.     }
  561.     process_alarm(0);
  562.   }
  563.   bzero((char*) &alarm_thread,sizeof(alarm_thread)); /* For easy debugging */
  564.   alarm_thread_running= 0;
  565.   pthread_cond_signal(&COND_alarm);
  566.   pthread_mutex_unlock(&LOCK_alarm);
  567.   pthread_exit(0);
  568.   return 0; /* Impossible */
  569. }
  570. #endif /* USE_ALARM_THREAD */
  572. /*****************************************************************************
  573.   thr_alarm for OS/2
  574. *****************************************************************************/
  576. #elif defined(__EMX__) || defined(OS2)
  578. #define INCL_BASE
  579. #define INCL_NOPMAPI
  580. #include <os2.h>
  582. static pthread_mutex_t LOCK_alarm;
  583. static sigset_t full_signal_set;
  584. static QUEUE alarm_queue;
  585. pthread_t alarm_thread;
  587. #ifdef USE_ALARM_THREAD
  588. static pthread_cond_t COND_alarm;
  589. static void *alarm_handler(void *arg);
  590. #define reschedule_alarms() pthread_cond_signal(&COND_alarm)
  591. #else
  592. #define reschedule_alarms() pthread_kill(alarm_thread,THR_SERVER_ALARM)
  593. #endif
  595. sig_handler process_alarm(int sig __attribute__((unused)))
  596. {
  597.   sigset_t old_mask;
  598.   ALARM *alarm_data;
  599.   DBUG_PRINT("info",("sig: %d active alarms: %d",sig,alarm_queue.elements));
  600. }
  603. /*
  604.   Remove another thread from the alarm
  605. */
  607. void thr_alarm_kill(pthread_t thread_id)
  608. {
  609.   uint i;
  611.   pthread_mutex_lock(&LOCK_alarm);
  612.   for (i=0 ; i < alarm_queue.elements ; i++)
  613.   {
  614.     if (pthread_equal(((ALARM*) queue_element(&alarm_queue,i))->thread,
  615.       thread_id))
  616.     {
  617.       ALARM *tmp=(ALARM*) queue_remove(&alarm_queue,i);
  618.       tmp->expire_time=0;
  619.       queue_insert(&alarm_queue,(byte*) tmp);
  620.       reschedule_alarms();
  621.       break;
  622.     }
  623.   }
  624.   pthread_mutex_unlock(&LOCK_alarm);
  625. }
  627. bool thr_alarm(thr_alarm_t *alrm, uint sec, ALARM *alarm)
  628. {
  629.   APIRET rc;
  630.   if (alarm_aborted)
  631.   {
  632.     alarm->alarmed.crono=0;
  633.     alarm->alarmed.event=0;
  634.     return 1;
  635.   }
  636.   if (rc = DosCreateEventSem(NULL,(HEV *) &alarm->alarmed.event,
  637.      DC_SEM_SHARED,FALSE))
  638.   {
  639.     printf("Error creating event semaphore! [%d] n",rc);
  640.     alarm->alarmed.crono=0;
  641.     alarm->alarmed.event=0;
  642.     return 1;
  643.   }
  644.   if (rc = DosAsyncTimer((long) sec*1000L, (HSEM) alarm->alarmed.event,
  645.  (HTIMER *) &alarm->alarmed.crono))
  646.   {
  647.     printf("Error starting async timer! [%d] n",rc);
  648.     DosCloseEventSem((HEV) alarm->alarmed.event);
  649.     alarm->alarmed.crono=0;
  650.     alarm->alarmed.event=0;
  651.     return 1;
  652.   } /* endif */
  653.   (*alrm)= &alarm->alarmed;
  654.   return 1;
  655. }
  658. bool thr_got_alarm(thr_alarm_t *alrm_ptr)
  659. {
  660.   thr_alarm_t alrm= *alrm_ptr;
  661.   APIRET rc;
  663.   if (alrm->crono)
  664.   {
  665.     rc = DosWaitEventSem((HEV) alrm->event, SEM_IMMEDIATE_RETURN);
  666.     if (rc == 0) {
  667.       DosCloseEventSem((HEV) alrm->event);
  668.       alrm->crono = 0;
  669.       alrm->event = 0;
  670.     } /* endif */
  671.   }
  672.   return !alrm->crono || alarm_aborted;
  673. }
  676. void thr_end_alarm(thr_alarm_t *alrm_ptr)
  677. {
  678.   thr_alarm_t alrm= *alrm_ptr;
  679.   if (alrm->crono)
  680.   {
  681.     DosStopTimer((HTIMER) alrm->crono);
  682.     DosCloseEventSem((HEV) alrm->event);
  683.     alrm->crono = 0;
  684.     alrm->event = 0;
  685.   }
  686. }
  688. void end_thr_alarm(my_bool free_structures)
  689. {
  690.   DBUG_ENTER("end_thr_alarm");
  691.   alarm_aborted=1; /* No more alarms */
  692.   DBUG_VOID_RETURN;
  693. }
  695. void init_thr_alarm(uint max_alarm)
  696. {
  697.   DBUG_ENTER("init_thr_alarm");
  698.   alarm_aborted=0; /* Yes, Gimmie alarms */
  699.   DBUG_VOID_RETURN;
  700. }
  702. void thr_alarm_info(ALARM_INFO *info)
  703. {
  704.   bzero((char*) info, sizeof(*info));
  705. }
  707. void resize_thr_alarm(uint max_alarms)
  708. {
  709. }
  711. /*****************************************************************************
  712.   thr_alarm for win95
  713. *****************************************************************************/
  715. #else /* __WIN__ */
  717. void thr_alarm_kill(pthread_t thread_id)
  718. {
  719.   /* Can't do this yet */
  720. }
  722. sig_handler process_alarm(int sig __attribute__((unused)))
  723. {
  724.   /* Can't do this yet */
  725. }
  728. my_bool thr_alarm(thr_alarm_t *alrm, uint sec, ALARM *alarm)
  729. {
  730.   (*alrm)= &alarm->alarmed;
  731.   if (alarm_aborted)
  732.   {
  733.     alarm->alarmed.crono=0;
  734.     return 1;
  735.   }
  736.   if (!(alarm->alarmed.crono=SetTimer((HWND) NULL,0, sec*1000,
  737.       (TIMERPROC) NULL)))
  738.     return 1;
  739.   return 0;
  740. }
  743. bool thr_got_alarm(thr_alarm_t *alrm_ptr)
  744. {
  745.   thr_alarm_t alrm= *alrm_ptr;
  746.   MSG msg;
  747.   if (alrm->crono)
  748.   {
  749.     PeekMessage(&msg,NULL,WM_TIMER,WM_TIMER,PM_REMOVE) ;
  750.     if (msg.message == WM_TIMER || alarm_aborted)
  751.     {
  752.       KillTimer(NULL, alrm->crono);
  753.       alrm->crono = 0;
  754.     }
  755.   }
  756.   return !alrm->crono || alarm_aborted;
  757. }
  760. void thr_end_alarm(thr_alarm_t *alrm_ptr)
  761. {
  762.   thr_alarm_t alrm= *alrm_ptr;
  763.   /* alrm may be zero if thr_alarm aborted with an error */
  764.   if (alrm && alrm->crono)
  766.   {
  767.     KillTimer(NULL, alrm->crono);
  768.     alrm->crono = 0;
  769.   }
  770. }
  772. void end_thr_alarm(my_bool free_structures)
  773. {
  774.   DBUG_ENTER("end_thr_alarm");
  775.   alarm_aborted=1; /* No more alarms */
  776.   DBUG_VOID_RETURN;
  777. }
  779. void init_thr_alarm(uint max_alarm)
  780. {
  781.   DBUG_ENTER("init_thr_alarm");
  782.   alarm_aborted=0; /* Yes, Gimmie alarms */
  783.   DBUG_VOID_RETURN;
  784. }
  786. void thr_alarm_info(ALARM_INFO *info)
  787. {
  788.   bzero((char*) info, sizeof(*info));
  789. }
  791. void resize_thr_alarm(uint max_alarms)
  792. {
  793. }
  795. #endif /* __WIN__ */
  797. #endif /* THREAD */
  800. /****************************************************************************
  801.   Handling of test case (when compiled with -DMAIN)
  802. ***************************************************************************/
  804. #ifdef MAIN
  805. #if defined(THREAD) && !defined(DONT_USE_THR_ALARM)
  807. static pthread_cond_t COND_thread_count;
  808. static pthread_mutex_t LOCK_thread_count;
  809. static uint thread_count;
  811. #ifdef HPUX10
  812. typedef int * fd_set_ptr;
  813. #else
  814. typedef fd_set * fd_set_ptr;
  815. #endif /* HPUX10 */
  817. static void *test_thread(void *arg)
  818. {
  819.   int i,param=*((int*) arg),wait_time,retry;
  820.   time_t start_time;
  821.   thr_alarm_t got_alarm;
  822.   fd_set fd;
  823.   FD_ZERO(&fd);
  824.   my_thread_init();
  825.   printf("Thread %d (%s) startedn",param,my_thread_name()); fflush(stdout);
  826.   for (i=1 ; i <= 10 ; i++)
  827.   {
  828.     wait_time=param ? 11-i : i;
  829.     start_time=time((time_t*) 0);
  830.     if (thr_alarm(&got_alarm,wait_time,0))
  831.     {
  832.       printf("Thread: %s  Alarms abortedn",my_thread_name());
  833.       break;
  834.     }
  835.     if (wait_time == 3)
  836.     {
  837.       printf("Thread: %s  Simulation of no alarm neededn",my_thread_name());
  838.       fflush(stdout);
  839.     }
  840.     else
  841.     {
  842.       for (retry=0 ; !thr_got_alarm(&got_alarm) && retry < 10 ; retry++)
  843.       {
  844. printf("Thread: %s  Waiting %d secn",my_thread_name(),wait_time);
  845. select(0,(fd_set_ptr) &fd,0,0,0);
  846.       }
  847.       if (!thr_got_alarm(&got_alarm))
  848.       {
  849. printf("Thread: %s  didn't get an alarm. Aborting!n",
  850.        my_thread_name());
  851. break;
  852.       }
  853.       if (wait_time == 7)
  854.       { /* Simulate alarm-miss */
  855. fd_set readFDs;
  856. uint max_connection=fileno(stdin);
  857. FD_ZERO(&readFDs);
  858. FD_SET(max_connection,&readFDs);
  859. retry=0;
  860. for (;;)
  861. {
  862.   printf("Thread: %s  Simulating alarm missn",my_thread_name());
  863.   fflush(stdout);
  864.   if (select(max_connection+1, (fd_set_ptr) &readFDs,0,0,0) < 0)
  865.   {
  866.     if (errno == EINTR)
  867.       break; /* Got new interrupt */
  868.     printf("Got errno: %d from select.  Retrying..n",errno);
  869.     if (retry++ >= 3)
  870.     {
  871.       printf("Warning:  Interrupt of select() doesn't set errno!n");
  872.       break;
  873.     }
  874.   }
  875.   else /* This shouldn't happen */
  876.   {
  877.     if (!FD_ISSET(max_connection,&readFDs))
  878.     {
  879.       printf("Select interrupted, but errno not setn");
  880.       fflush(stdout);
  881.       if (retry++ >= 3)
  882. break;
  883.       continue;
  884.     }
  885.     VOID(getchar()); /* Somebody was playing */
  886.   }
  887. }
  888.       }
  889.     }
  890.     printf("Thread: %s  Slept for %d (%d) secn",my_thread_name(),
  891.    (int) (time((time_t*) 0)-start_time), wait_time); fflush(stdout);
  892.     thr_end_alarm(&got_alarm);
  893.     fflush(stdout);
  894.   }
  895.   pthread_mutex_lock(&LOCK_thread_count);
  896.   thread_count--;
  897.   VOID(pthread_cond_signal(&COND_thread_count)); /* Tell main we are ready */
  898.   pthread_mutex_unlock(&LOCK_thread_count);
  899.   free((gptr) arg);
  900.   return 0;
  901. }
  903. #ifdef USE_ONE_SIGNAL_HAND
  904. static sig_handler print_signal_warning(int sig)
  905. {
  906.   printf("Warning: Got signal %d from thread %sn",sig,my_thread_name());
  907.   fflush(stdout);
  908. #ifdef DONT_REMEMBER_SIGNAL
  909.   my_sigset(sig,print_signal_warning); /* int. thread system calls */
  910. #endif
  911. #ifndef OS2
  912.   if (sig == SIGALRM)
  913.     alarm(2); /* reschedule alarm */
  914. #endif
  915. }
  916. #endif /* USE_ONE_SIGNAL_HAND */
  919. static void *signal_hand(void *arg __attribute__((unused)))
  920. {
  921.   sigset_t set;
  922.   int sig,error,err_count=0;;
  924.   my_thread_init();
  925.   pthread_detach_this_thread();
  926.   init_thr_alarm(10); /* Setup alarm handler */
  927.   pthread_mutex_lock(&LOCK_thread_count); /* Required by bsdi */
  928.   VOID(pthread_cond_signal(&COND_thread_count)); /* Tell main we are ready */
  929.   pthread_mutex_unlock(&LOCK_thread_count);
  931. #ifndef OS2
  932.   sigemptyset(&set); /* Catch all signals */
  933.   sigaddset(&set,SIGINT);
  934.   sigaddset(&set,SIGQUIT);
  935.   sigaddset(&set,SIGTERM);
  936. #if THR_CLIENT_ALARM != SIGHUP
  937.   sigaddset(&set,SIGHUP);
  938. #endif
  939. #ifdef SIGTSTP
  940.   sigaddset(&set,SIGTSTP);
  941. #endif
  942. #ifdef USE_ONE_SIGNAL_HAND
  943.   sigaddset(&set,THR_SERVER_ALARM); /* For alarms */
  944.   puts("Starting signal and alarm handling thread");
  945. #else
  946.   puts("Starting signal handling thread");
  947. #endif
  948. #endif /* OS2 */
  949.   printf("server alarm: %d  thread alarm: %dn",
  950.  THR_SERVER_ALARM,THR_CLIENT_ALARM);
  951.   DBUG_PRINT("info",("Starting signal and alarm handling thread"));
  952.   for(;;)
  953.   {
  954.     while ((error=my_sigwait(&set,&sig)) == EINTR)
  955.       printf("sigwait restartedn");
  956.     if (error)
  957.     {
  958.       fprintf(stderr,"Got error %d from sigwaitn",error);
  959.       if (err_count++ > 5)
  960. exit(1); /* Too many errors in test */
  961.       continue;
  962.     }
  963. #ifdef USE_ONE_SIGNAL_HAND
  964.     if (sig != THR_SERVER_ALARM)
  965. #endif
  966.       printf("Main thread: Got signal %dn",sig);
  967.     switch (sig) {
  968.     case SIGINT:
  969.     case SIGQUIT:
  970.     case SIGTERM:
  971. #ifndef OS2
  972.     case SIGHUP:
  973. #endif
  974.       printf("Aborting nicelyn");
  975.       end_thr_alarm(0);
  976.       break;
  977. #ifdef SIGTSTP
  978.     case SIGTSTP:
  979.       printf("Abortingn");
  980.       exit(1);
  981.       return 0; /* Keep some compilers happy */
  982. #endif
  983. #ifndef OS2
  984. #ifdef USE_ONE_SIGNAL_HAND
  985.      case THR_SERVER_ALARM:
  986.        process_alarm(sig);
  987.       break;
  988. #endif
  989. #endif /* OS2 */
  990.     }
  991.   }
  992. }
  995. int main(int argc __attribute__((unused)),char **argv __attribute__((unused)))
  996. {
  997.   pthread_t tid;
  998.   pthread_attr_t thr_attr;
  999.   int i,*param,error;
  1000.   sigset_t set;
  1001.   ALARM_INFO alarm_info;
  1002.   MY_INIT(argv[0]);
  1004.   if (argc > 1 && argv[1][0] == '-' && argv[1][1] == '#')
  1005.     DBUG_PUSH(argv[1]+2);
  1007.   pthread_mutex_init(&LOCK_thread_count,MY_MUTEX_INIT_FAST);
  1008.   pthread_cond_init(&COND_thread_count,NULL);
  1010.   /* Start a alarm handling thread */
  1011. #ifndef OS2
  1012.   sigemptyset(&set);
  1013.   sigaddset(&set,SIGINT);
  1014.   sigaddset(&set,SIGQUIT);
  1015.   sigaddset(&set,SIGTERM);
  1016.   sigaddset(&set,SIGHUP);
  1017.   signal(SIGTERM,SIG_DFL); /* If it's blocked by parent */
  1018. #ifdef SIGTSTP
  1019.   sigaddset(&set,SIGTSTP);
  1020. #endif
  1021.   sigaddset(&set,THR_SERVER_ALARM);
  1022.   sigdelset(&set,THR_CLIENT_ALARM);
  1023.   (void) pthread_sigmask(SIG_SETMASK,&set,NULL);
  1024. #ifdef NOT_USED
  1025.   sigemptyset(&set);
  1026.   sigaddset(&set,THR_CLIENT_ALARM);
  1027.   VOID(pthread_sigmask(SIG_UNBLOCK, &set, (sigset_t*) 0));
  1028. #endif
  1029. #endif /* OS2 */
  1031.   pthread_attr_init(&thr_attr);
  1032.   pthread_attr_setscope(&thr_attr,PTHREAD_SCOPE_PROCESS);
  1033.   pthread_attr_setdetachstate(&thr_attr,PTHREAD_CREATE_DETACHED);
  1034.   pthread_attr_setstacksize(&thr_attr,65536L);
  1036.   /* Start signal thread and wait for it to start */
  1037.   VOID(pthread_mutex_lock(&LOCK_thread_count));
  1038.   pthread_create(&tid,&thr_attr,signal_hand,NULL);
  1039.   VOID(pthread_cond_wait(&COND_thread_count,&LOCK_thread_count));
  1040.   VOID(pthread_mutex_unlock(&LOCK_thread_count));
  1041.   DBUG_PRINT("info",("signal thread created"));
  1043.   thr_setconcurrency(3);
  1044.   pthread_attr_setscope(&thr_attr,PTHREAD_SCOPE_PROCESS);
  1045.   printf("Main thread: %sn",my_thread_name());
  1046.   for (i=0 ; i < 2 ; i++)
  1047.   {
  1048.     param=(int*) malloc(sizeof(int));
  1049.     *param= i;
  1050.     pthread_mutex_lock(&LOCK_thread_count);
  1051.     if ((error=pthread_create(&tid,&thr_attr,test_thread,(void*) param)))
  1052.     {
  1053.       printf("Can't create thread %d, error: %dn",i,error);
  1054.       exit(1);
  1055.     }
  1056.     thread_count++;
  1057.     pthread_mutex_unlock(&LOCK_thread_count);
  1058.   }
  1060.   pthread_attr_destroy(&thr_attr);
  1061.   pthread_mutex_lock(&LOCK_thread_count);
  1062.   thr_alarm_info(&alarm_info);
  1063.   printf("Main_thread:  Alarms: %u  max_alarms: %u  next_alarm_time: %lun",
  1064.  alarm_info.active_alarms, alarm_info.max_used_alarms,
  1065.  alarm_info.next_alarm_time);
  1066.   while (thread_count)
  1067.   {
  1068.     VOID(pthread_cond_wait(&COND_thread_count,&LOCK_thread_count));
  1069.     if (thread_count == 1)
  1070.     {
  1071.       printf("Calling end_thr_alarm. This should cancel the last threadn");
  1072.       end_thr_alarm(0);
  1073.     }
  1074.   }
  1075.   pthread_mutex_unlock(&LOCK_thread_count);
  1076.   end_thr_alarm(1);
  1077.   thr_alarm_info(&alarm_info);
  1078.   printf("Main_thread:  Alarms: %u  max_alarms: %u  next_alarm_time: %lun",
  1079.  alarm_info.active_alarms, alarm_info.max_used_alarms,
  1080.  alarm_info.next_alarm_time);
  1081.   printf("Test succeededn");
  1082.   return 0;
  1083. }
  1085. #else /* THREAD */
  1087. int main(int argc __attribute__((unused)),char **argv __attribute__((unused)))
  1088. {
  1089. #ifndef THREAD
  1090.   printf("thr_alarm disabled because we are not using threadsn");
  1091. #else
  1092.   printf("thr_alarm disabled with DONT_USE_THR_ALARMn");
  1093. #endif
  1094.   exit(1);
  1095. }
  1097. #endif /* THREAD */
  1098. #endif /* MAIN */