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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
thr_alarm.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：24k
源码类别：

MySQL数据库

开发平台：

Visual C++

thr_alarm.c：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This library is free software; you can redistribute it and/or
  4.    modify it under the terms of the GNU Library General Public
  5.    License as published by the Free Software Foundation; either
  6.    version 2 of the License, or (at your option) any later version.
  7.    
  8.    This library 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 GNU
  11.    Library General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU Library General Public
  14.    License along with this library; if not, write to the Free
  15.    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  16.    MA 02111-1307, USA */
  18. #include <global.h>
  20. #if defined(THREAD) && !defined(DONT_USE_THR_ALARM)
  21. #include <errno.h>
  22. #include <my_pthread.h>
  23. #include <signal.h>
  24. #include <my_sys.h>
  25. #include <m_string.h>
  26. #include <queues.h>
  27. #include "thr_alarm.h"
  29. #ifdef HAVE_SYS_SELECT_H
  30. #include <sys/select.h> /* AIX needs this for fd_set */
  31. #endif
  33. #ifndef ETIME
  34. #define ETIME ETIMEDOUT
  35. #endif
  37. static my_bool alarm_aborted=1;
  38. my_bool thr_alarm_inited=0;
  40. #if !defined(__WIN__) && !defined(__EMX__)
  42. static pthread_mutex_t LOCK_alarm;
  43. static sigset_t full_signal_set;
  44. static QUEUE alarm_queue;
  45. pthread_t alarm_thread;
  47. #ifdef USE_ALARM_THREAD
  48. static pthread_cond_t COND_alarm;
  49. static void *alarm_handler(void *arg);
  50. #define reschedule_alarms() pthread_cond_signal(&COND_alarm)
  51. #else
  52. #define reschedule_alarms() pthread_kill(alarm_thread,THR_SERVER_ALARM)
  53. #endif
  55. #if THR_CLIENT_ALARM != SIGALRM || defined(USE_ALARM_THREAD)
  56. static sig_handler thread_alarm(int sig __attribute__((unused)));
  57. #endif
  59. static int compare_ulong(void *not_used __attribute__((unused)),
  60.  byte *a_ptr,byte* b_ptr)
  61. {
  62.   ulong a=*((ulong*) a_ptr),b= *((ulong*) b_ptr);
  63.   return (a < b) ? -1  : (a == b) ? 0 : 1;
  64. }
  66. void init_thr_alarm(uint max_alarms)
  67. {
  68.   sigset_t s;
  69.   DBUG_ENTER("init_thr_alarm");
  70.   alarm_aborted=0;
  71.   init_queue(&alarm_queue,max_alarms+1,offsetof(ALARM,expire_time),0,
  72.      compare_ulong,NullS);
  73.   sigfillset(&full_signal_set); /* Neaded to block signals */
  74.   pthread_mutex_init(&LOCK_alarm,NULL);
  75. #if THR_CLIENT_ALARM != SIGALRM || defined(USE_ALARM_THREAD)
  76. #if defined(HAVE_mit_thread)
  77.   sigset(THR_CLIENT_ALARM,thread_alarm); /* int. thread system calls */
  78. #else
  79.   {
  80.     struct sigaction sact;
  81.     sact.sa_flags = 0;
  82.     sact.sa_handler = thread_alarm;
  83.     sigaction(THR_CLIENT_ALARM, &sact, (struct sigaction*) 0);
  84.   }
  85. #endif
  86. #endif
  87.   sigemptyset(&s);
  88.   sigaddset(&s, THR_SERVER_ALARM);
  89.   alarm_thread=pthread_self();
  90. #if defined(USE_ALARM_THREAD)
  91.   {
  92.     pthread_attr_t thr_attr;
  93.     pthread_attr_init(&thr_attr);
  94.     pthread_cond_init(&COND_alarm,NULL);
  95.     pthread_attr_setscope(&thr_attr,PTHREAD_SCOPE_PROCESS);
  96.     pthread_attr_setdetachstate(&thr_attr,PTHREAD_CREATE_DETACHED);
  97.     pthread_attr_setstacksize(&thr_attr,8196);
  99.     my_pthread_attr_setprio(&thr_attr,100); /* Very high priority */
  100.     VOID(pthread_create(&alarm_thread,&thr_attr,alarm_handler,NULL));
  101.     VOID(pthread_attr_destroy(&thr_attr));
  102.   }
  103. #elif defined(USE_ONE_SIGNAL_HAND)
  104.   pthread_sigmask(SIG_BLOCK, &s, NULL); /* used with sigwait() */
  105. #if THR_SERVER_ALARM == THR_CLIENT_ALARM
  106.   sigset(THR_CLIENT_ALARM,process_alarm); /* Linuxthreads */
  107.   pthread_sigmask(SIG_UNBLOCK, &s, NULL);
  108. #endif
  109. #else
  110.   pthread_sigmask(SIG_UNBLOCK, &s, NULL);
  111.   sigset(THR_SERVER_ALARM,process_alarm);
  112. #endif
  113.   DBUG_VOID_RETURN;
  114. }
  116. /*
  117. ** Request alarm after sec seconds.
  118. ** A pointer is returned with points to a non-zero int when the alarm has been
  119. ** given. This can't be called from the alarm-handling thread.
  120. ** Returns 0 if no more alarms are allowed (aborted by process)
  121. */
  123. bool thr_alarm(thr_alarm_t *alrm, uint sec, ALARM *alarm_data)
  124. {
  125.   ulong now;
  126.   sigset_t old_mask;
  127.   my_bool reschedule;
  128.   DBUG_ENTER("thr_alarm");
  129.   DBUG_PRINT("enter",("thread: %s  sec: %d",my_thread_name(),sec));
  131.   now=(ulong) time((time_t*) 0);
  132.   pthread_sigmask(SIG_BLOCK,&full_signal_set,&old_mask);
  133.   pthread_mutex_lock(&LOCK_alarm); /* Lock from threads & alarms */
  134.   if (alarm_aborted)
  135.   { /* No signal thread */
  136.     DBUG_PRINT("info", ("alarm aborted"));
  137.     pthread_mutex_unlock(&LOCK_alarm);
  138.     pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
  139.     DBUG_RETURN(1);
  140.   }
  141.   if (alarm_queue.elements == alarm_queue.max_elements)
  142.   {
  143.     DBUG_PRINT("info", ("alarm queue full"));
  144.     fprintf(stderr,"Warning: thr_alarm queue is fulln");
  145.     pthread_mutex_unlock(&LOCK_alarm);
  146.     pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
  147.     DBUG_RETURN(1);
  148.   }
  149.   reschedule= (!alarm_queue.elements ||
  150.       (int) (((ALARM*) queue_top(&alarm_queue))->expire_time - now) >
  151.       (int) sec);
  152.   if (!alarm_data)
  153.   {
  154.     if (!(alarm_data=(ALARM*) my_malloc(sizeof(ALARM),MYF(MY_WME))))
  155.     {
  156.       DBUG_PRINT("info", ("failed my_malloc()"));
  157.       pthread_mutex_unlock(&LOCK_alarm);
  158.       pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
  159.       DBUG_RETURN(1);
  160.     }
  161.     alarm_data->malloced=1;
  162.   }
  163.   else
  164.     alarm_data->malloced=0;
  165.   alarm_data->expire_time=now+sec;
  166.   alarm_data->alarmed=0;
  167.   alarm_data->thread=pthread_self();
  168.   queue_insert(&alarm_queue,(byte*) alarm_data);
  170.   /* Reschedule alarm if the current one has more than sec left */
  171.   if (reschedule)
  172.   {
  173.     DBUG_PRINT("info", ("reschedule"));
  174.     if (pthread_equal(pthread_self(),alarm_thread))
  175.       alarm(sec); /* purecov: inspected */
  176.     else
  177.       reschedule_alarms(); /* Reschedule alarms */
  178.   }
  179.   pthread_mutex_unlock(&LOCK_alarm);
  180.   pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
  181.   (*alrm)= &alarm_data->alarmed;
  182.   DBUG_RETURN(0);
  183. }
  186. /*
  187. ** Remove alarm from list of alarms
  188. */
  190. void thr_end_alarm(thr_alarm_t *alarmed)
  191. {
  192.   ALARM *alarm_data;
  193.   sigset_t old_mask;
  194.   uint i;
  195.   bool found=0;
  196.   DBUG_ENTER("thr_end_alarm");
  198.   pthread_sigmask(SIG_BLOCK,&full_signal_set,&old_mask);
  199.   pthread_mutex_lock(&LOCK_alarm);
  201.   alarm_data= (ALARM*) ((byte*) *alarmed - offsetof(ALARM,alarmed));
  202.   for (i=0 ; i < alarm_queue.elements ; i++)
  203.   {
  204.     if ((ALARM*) queue_element(&alarm_queue,i) == alarm_data)
  205.     {
  206.       queue_remove(&alarm_queue,i),MYF(0);
  207.       if (alarm_data->malloced)
  208. my_free((gptr) alarm_data,MYF(0));
  209.       found=1;
  210.       break;
  211.     }
  212.   }
  213.   if (!found)
  214.   {
  215. #ifdef MAIN
  216.     printf("Warning: Didn't find alarm %lx in queue of %d alarmsn",
  217.    (long) *alarmed, alarm_queue.elements);
  218. #endif
  219.     DBUG_PRINT("warning",("Didn't find alarm %lx in queuen",*alarmed));
  220.   }
  221.   if (alarm_aborted && !alarm_queue.elements)
  222.     delete_queue(&alarm_queue);
  223.   pthread_mutex_unlock(&LOCK_alarm);
  224.   pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
  225.   DBUG_VOID_RETURN;
  226. }
  228. /*
  229.   Come here when some alarm in queue is due.
  230.   Mark all alarms with are finnished in list.
  231.   Shedule alarms to be sent again after 1-10 sec (many alarms at once)
  232.   If alarm_aborted is set then all alarms are given and resent
  233.   every second.
  234.   */
  236. sig_handler process_alarm(int sig __attribute__((unused)))
  237. {
  238.   sigset_t old_mask;
  239.   ALARM *alarm_data;
  240.   DBUG_ENTER("process_alarm");
  241.   DBUG_PRINT("info",("sig: %d active alarms: %d",sig,alarm_queue.elements));
  243. #if THR_SERVER_ALARM == THR_CLIENT_ALARM
  244.   if (!pthread_equal(pthread_self(),alarm_thread))
  245.   {
  246. #if defined(MAIN) && !defined(__bsdi__)
  247.     printf("thread_alarmn"); fflush(stdout);
  248. #endif
  249. #ifdef DONT_REMEMBER_SIGNAL
  250.     sigset(THR_CLIENT_ALARM,process_alarm); /* int. thread system calls */
  251. #endif
  252.     DBUG_VOID_RETURN;
  253.   }
  254. #endif
  256. #if defined(MAIN) && !defined(__bsdi__)
  257.   printf("process_alarmn"); fflush(stdout);
  258. #endif
  259. #ifndef USE_ALARM_THREAD
  260.   pthread_sigmask(SIG_SETMASK,&full_signal_set,&old_mask);
  261.   pthread_mutex_lock(&LOCK_alarm);
  262. #endif
  263.   if (alarm_queue.elements)
  264.   {
  265.     if (alarm_aborted)
  266.     {
  267.       uint i;
  268.       for (i=0 ; i < alarm_queue.elements ;)
  269.       {
  270. alarm_data=(ALARM*) queue_element(&alarm_queue,i);
  271. alarm_data->alarmed=1; /* Info to thread */
  272. if (pthread_equal(alarm_data->thread,alarm_thread) ||
  273.     pthread_kill(alarm_data->thread, THR_CLIENT_ALARM))
  274. {
  275. #ifdef MAIN
  276.   printf("Warning: pthread_kill couldn't find thread!!!n");
  277. #endif
  278.   queue_remove(&alarm_queue,i); /* No thread. Remove alarm */
  279. }
  280. else
  281.   i++; /* Signal next thread */
  282.       }
  283. #ifndef USE_ALARM_THREAD
  284.       if (alarm_queue.elements)
  285. alarm(1); /* Signal soon again */
  286. #endif
  287.     }
  288.     else
  289.     {
  290.       ulong now=(ulong) time((time_t*) 0);
  291.       ulong next=now+10-(now%10);
  292.       while ((alarm_data=(ALARM*) queue_top(&alarm_queue))->expire_time <= now)
  293.       {
  294. alarm_data->alarmed=1; /* Info to thread */
  295. DBUG_PRINT("info",("sending signal to waiting thread"));
  296. if (pthread_equal(alarm_data->thread,alarm_thread) ||
  297.     pthread_kill(alarm_data->thread, THR_CLIENT_ALARM))
  298. {
  299. #ifdef MAIN
  300.   printf("Warning: pthread_kill couldn't find thread!!!n");
  301. #endif
  302.   queue_remove(&alarm_queue,0); /* No thread. Remove alarm */
  303.   if (!alarm_queue.elements)
  304.     break;
  305. }
  306. else
  307. {
  308.   alarm_data->expire_time=next;
  309.   queue_replaced(&alarm_queue);
  310. }
  311.       }
  312. #ifndef USE_ALARM_THREAD
  313.       if (alarm_queue.elements)
  314.       {
  315. #ifdef __bsdi__
  316. alarm(0); /* Remove old alarm */
  317. #endif
  318. alarm((uint) (alarm_data->expire_time-now));
  319.       }
  320. #endif
  321.     }
  322.   }
  323. #ifndef USE_ALARM_THREAD
  324. #if defined(DONT_REMEMBER_SIGNAL) && !defined(USE_ONE_SIGNAL_HAND)
  325.   sigset(THR_SERVER_ALARM,process_alarm);
  326. #endif
  327.   pthread_mutex_unlock(&LOCK_alarm);
  328.   pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
  329. #endif
  330.   DBUG_VOID_RETURN;
  331. }
  334. /*
  335. ** Shedule all alarms now.
  336. ** When all alarms are given, Free alarm memory and don't allow more alarms.
  337. */
  339. void end_thr_alarm(void)
  340. {
  341.   DBUG_ENTER("end_thr_alarm");
  342.   pthread_mutex_lock(&LOCK_alarm);
  343.   if (!alarm_aborted)
  344.   {
  345.     DBUG_PRINT("info",("Resheduling %d waiting alarms",alarm_queue.elements));
  346.     alarm_aborted=1; /* mark aborted */
  347.     if (!alarm_queue.elements)
  348.       delete_queue(&alarm_queue);
  349.     if (pthread_equal(pthread_self(),alarm_thread))
  350.       alarm(1); /* Shut down everything soon */
  351.     else
  352.       reschedule_alarms();
  353.   }
  354.   pthread_mutex_unlock(&LOCK_alarm);
  355.   DBUG_VOID_RETURN;
  356. }
  359. /*
  360. ** Remove another thread from the alarm
  361. */
  363. void thr_alarm_kill(pthread_t thread_id)
  364. {
  365.   uint i;
  366.   pthread_mutex_lock(&LOCK_alarm);
  367.   for (i=0 ; i < alarm_queue.elements ; i++)
  368.   {
  369.     if (pthread_equal(((ALARM*) queue_element(&alarm_queue,i))->thread,
  370.       thread_id))
  371.     {
  372.       ALARM *tmp=(ALARM*) queue_remove(&alarm_queue,i);
  373.       tmp->expire_time=0;
  374.       queue_insert(&alarm_queue,(byte*) tmp);
  375.       reschedule_alarms();
  376.       break;
  377.     }
  378.   }
  379.   pthread_mutex_unlock(&LOCK_alarm);
  380. }
  383. /*
  384. **  This is here for thread to get interruptet from read/write/fcntl
  385. **  ARGSUSED
  386. */
  388. #if THR_CLIENT_ALARM != SIGALRM || defined(USE_ALARM_THREAD)
  389. static sig_handler thread_alarm(int sig)
  390. {
  391. #ifdef MAIN
  392.   printf("thread_alarmn"); fflush(stdout);
  393. #endif
  394. #ifdef DONT_REMEMBER_SIGNAL
  395.   sigset(sig,thread_alarm); /* int. thread system calls */
  396. #endif
  397. }
  398. #endif
  401. #ifdef HAVE_TIMESPEC_TS_SEC
  402. #define tv_sec ts_sec
  403. #define tv_nsec ts_nsec
  404. #endif
  406. /* set up a alarm thread with uses 'sleep' to sleep between alarms */
  408. #ifdef USE_ALARM_THREAD
  409. static void *alarm_handler(void *arg __attribute__((unused)))
  410. {
  411.   int error;
  412.   struct timespec abstime;
  413. #ifdef MAIN
  414.   puts("Starting alarm thread");
  415. #endif
  416.   my_thread_init();
  417.   pthread_mutex_lock(&LOCK_alarm);
  418.   for (;;)
  419.   {
  420.     if (alarm_queue.elements)
  421.     {
  422.       ulong sleep_time,now=time((time_t*) 0);
  423.       if (alarm_aborted)
  424. sleep_time=now+1;
  425.       else
  426. sleep_time= ((ALARM*) queue_top(&alarm_queue))->expire_time;
  427.       if (sleep_time > now)
  428.       {
  429. abstime.tv_sec=sleep_time;
  430. abstime.tv_nsec=0;
  431. if ((error=pthread_cond_timedwait(&COND_alarm,&LOCK_alarm,&abstime)) &&
  432.     error != ETIME && error != ETIMEDOUT)
  433. {
  434. #ifdef MAIN
  435.   printf("Got error: %d from ptread_cond_timedwait (errno: %d)n",
  436.  error,errno);
  437. #endif
  438. }
  439.       }
  440.     }
  441.     else if (alarm_aborted)
  442.       break;
  443.     else if ((error=pthread_cond_wait(&COND_alarm,&LOCK_alarm)))
  444.     {
  445. #ifdef MAIN
  446.       printf("Got error: %d from ptread_cond_wait (errno: %d)n",
  447.      error,errno);
  448. #endif
  449.     }
  450.     process_alarm(0);
  451.   }
  452.   bzero((char*) &alarm_thread,sizeof(alarm_thread)); /* For easy debugging */
  453.   pthread_mutex_unlock(&LOCK_alarm);
  454.   pthread_exit(0);
  455.   return 0; /* Impossible */
  456. }
  457. #endif /* USE_ALARM_THREAD */
  459. /*****************************************************************************
  460. **  thr_alarm for OS/2
  461. *****************************************************************************/
  463. #elif defined(__EMX__)
  465. #define INCL_BASE
  466. #define INCL_NOPMAPI
  467. #include <os2.h>
  469. static pthread_mutex_t LOCK_alarm;
  470. static sigset_t full_signal_set;
  471. static QUEUE alarm_queue;
  472. pthread_t alarm_thread;
  474. #ifdef USE_ALARM_THREAD
  475. static pthread_cond_t COND_alarm;
  476. static void *alarm_handler(void *arg);
  477. #define reschedule_alarms() pthread_cond_signal(&COND_alarm)
  478. #else
  479. #define reschedule_alarms() pthread_kill(alarm_thread,THR_SERVER_ALARM)
  480. #endif
  482. sig_handler process_alarm(int sig __attribute__((unused)))
  483. {
  484.   sigset_t old_mask;
  485.   ALARM *alarm_data;
  486.   DBUG_PRINT("info",("sig: %d active alarms: %d",sig,alarm_queue.elements));
  487. }
  490. /*
  491. ** Remove another thread from the alarm
  492. */
  494. void thr_alarm_kill(pthread_t thread_id)
  495. {
  496.   uint i;
  498.   pthread_mutex_lock(&LOCK_alarm);
  499.   for (i=0 ; i < alarm_queue.elements ; i++)
  500.   {
  501.     if (pthread_equal(((ALARM*) queue_element(&alarm_queue,i))->thread,
  502.       thread_id))
  503.     {
  504.       ALARM *tmp=(ALARM*) queue_remove(&alarm_queue,i);
  505.       tmp->expire_time=0;
  506.       queue_insert(&alarm_queue,(byte*) tmp);
  507.       reschedule_alarms();
  508.       break;
  509.     }
  510.   }
  511.   pthread_mutex_unlock(&LOCK_alarm);
  512. }
  514. bool thr_alarm(thr_alarm_t *alrm, uint sec, ALARM *alarm)
  515. {
  516.   APIRET rc;
  517.   if (alarm_aborted)
  518.   {
  519.     alarm->alarmed.crono=0;
  520.     alarm->alarmed.event=0;
  521.     return 1;
  522.   }
  523.   if (rc = DosCreateEventSem(NULL,(HEV *) &alarm->alarmed.event,
  524.      DC_SEM_SHARED,FALSE))
  525.   {
  526.     printf("Error creating event semaphore! [%d] n",rc);
  527.     alarm->alarmed.crono=0;
  528.     alarm->alarmed.event=0;
  529.     return 1;
  530.   }
  531.   if (rc = DosAsyncTimer((long) sec*1000L, (HSEM) alarm->alarmed.event,
  532.  (HTIMER *) &alarm->alarmed.crono))
  533.   {
  534.     printf("Error starting async timer! [%d] n",rc);
  535.     DosCloseEventSem((HEV) alarm->alarmed.event);
  536.     alarm->alarmed.crono=0;
  537.     alarm->alarmed.event=0;
  538.     return 1;
  539.   } /* endif */
  540.   (*alrm)= &alarm->alarmed;
  541.   return 1;
  542. }
  545. bool thr_got_alarm(thr_alarm_t *alrm_ptr)
  546. {
  547.   thr_alarm_t alrm= *alrm_ptr;
  548.   APIRET rc;
  550.   if (alrm->crono)
  551.   {
  552.     rc = DosWaitEventSem((HEV) alrm->event, SEM_IMMEDIATE_RETURN);
  553.     if (rc == 0) {
  554.       DosCloseEventSem((HEV) alrm->event);
  555.       alrm->crono = 0;
  556.       alrm->event = 0;
  557.     } /* endif */
  558.   }
  559.   return !alrm->crono || alarm_aborted;
  560. }
  563. void thr_end_alarm(thr_alarm_t *alrm_ptr)
  564. {
  565.   thr_alarm_t alrm= *alrm_ptr;
  566.   if (alrm->crono)
  567.   {
  568.     DosStopTimer((HTIMER) alrm->crono);
  569.     DosCloseEventSem((HEV) alrm->event);
  570.     alrm->crono = 0;
  571.     alrm->event = 0;
  572.   }
  573. }
  575. void end_thr_alarm(void)
  576. {
  577.   DBUG_ENTER("end_thr_alarm");
  578.   alarm_aborted=1; /* No more alarms */
  579.   DBUG_VOID_RETURN;
  580. }
  582. void init_thr_alarm(uint max_alarm)
  583. {
  584.   DBUG_ENTER("init_thr_alarm");
  585.   alarm_aborted=0; /* Yes, Gimmie alarms */
  586.   DBUG_VOID_RETURN;
  587. }
  589. /*****************************************************************************
  590. **  thr_alarm for win95
  591. *****************************************************************************/
  593. #else /* __WIN__ */
  595. void thr_alarm_kill(pthread_t thread_id)
  596. {
  597.   /* Can't do this yet */
  598. }
  600. sig_handler process_alarm(int sig __attribute__((unused)))
  601. {
  602.   /* Can't do this yet */
  603. }
  606. bool thr_alarm(thr_alarm_t *alrm, uint sec, ALARM *alarm)
  607. {
  608.   if (alarm_aborted)
  609.   {
  610.     alarm->alarmed.crono=0;
  611.     return 1;
  612.   }
  613.   if (!(alarm->alarmed.crono=SetTimer((HWND) NULL,0, sec*1000,
  614.       (TIMERPROC) NULL)))
  615.     return 1;
  616.   (*alrm)= &alarm->alarmed;
  617.   return 0;
  618. }
  621. bool thr_got_alarm(thr_alarm_t *alrm_ptr)
  622. {
  623.   thr_alarm_t alrm= *alrm_ptr;
  624.   MSG msg;
  625.   if (alrm->crono)
  626.   {
  627.     PeekMessage(&msg,NULL,WM_TIMER,WM_TIMER,PM_REMOVE) ;
  628.     if (msg.message == WM_TIMER || alarm_aborted)
  629.     {
  630.       KillTimer(NULL, alrm->crono);
  631.       alrm->crono = 0;
  632.     }
  633.   }
  634.   return !alrm->crono || alarm_aborted;
  635. }
  638. void thr_end_alarm(thr_alarm_t *alrm_ptr)
  639. {
  640.   thr_alarm_t alrm= *alrm_ptr;
  641.   if (alrm->crono)
  642.   {
  643.     KillTimer(NULL, alrm->crono);
  644.     alrm->crono = 0;
  645.   }
  646. }
  648. void end_thr_alarm(void)
  649. {
  650.   DBUG_ENTER("end_thr_alarm");
  651.   alarm_aborted=1; /* No more alarms */
  652.   DBUG_VOID_RETURN;
  653. }
  655. void init_thr_alarm(uint max_alarm)
  656. {
  657.   DBUG_ENTER("init_thr_alarm");
  658.   alarm_aborted=0; /* Yes, Gimmie alarms */
  659.   DBUG_VOID_RETURN;
  660. }
  662. #endif /* __WIN__ */
  664. #endif /* THREAD */
  667. /****************************************************************************
  668. ** Handling of MAIN
  669. ***************************************************************************/
  671. #ifdef MAIN
  672. #if defined(THREAD) && !defined(DONT_USE_THR_ALARM)
  674. static pthread_cond_t COND_thread_count;
  675. static pthread_mutex_t LOCK_thread_count;
  676. static uint thread_count;
  678. #ifdef HPUX
  679. typedef int * fd_set_ptr;
  680. #else
  681. typedef fd_set * fd_set_ptr;
  682. #endif /* HPUX */
  684. static void *test_thread(void *arg)
  685. {
  686.   int i,param=*((int*) arg),wait_time,retry;
  687.   time_t start_time;
  688.   thr_alarm_t got_alarm;
  689.   fd_set fd;
  690.   FD_ZERO(&fd);
  691.   my_thread_init();
  692.   printf("Thread %d (%s) startedn",param,my_thread_name()); fflush(stdout);
  693.   for (i=1 ; i <= 10 ; i++)
  694.   {
  695.     wait_time=param ? 11-i : i;
  696.     start_time=time((time_t*) 0);
  697.     if (thr_alarm(&got_alarm,wait_time,0))
  698.     {
  699.       printf("Thread: %s  Alarms abortedn",my_thread_name());
  700.       break;
  701.     }
  702.     if (wait_time == 3)
  703.     {
  704.       printf("Thread: %s  Simulation of no alarm neededn",my_thread_name());
  705.       fflush(stdout);
  706.     }
  707.     else
  708.     {
  709.       for (retry=0 ; !thr_got_alarm(&got_alarm) && retry < 10 ; retry++)
  710.       {
  711. printf("Thread: %s  Waiting %d secn",my_thread_name(),wait_time);
  712. select(0,(fd_set_ptr) &fd,0,0,0);
  713.       }
  714.       if (!thr_got_alarm(&got_alarm))
  715.       {
  716. printf("Thread: %s  didn't get an alarm. Aborting!n",
  717.        my_thread_name());
  718. break;
  719.       }
  720.       if (wait_time == 7)
  721.       { /* Simulate alarm-miss */
  722. fd_set readFDs;
  723. uint max_connection=fileno(stdin);
  724. FD_ZERO(&readFDs);
  725. FD_SET(max_connection,&readFDs);
  726. retry=0;
  727. for (;;)
  728. {
  729.   printf("Thread: %s  Simulating alarm missn",my_thread_name());
  730.   fflush(stdout);
  731.   if (select(max_connection+1, (fd_set_ptr) &readFDs,0,0,0) < 0)
  732.   {
  733.     if (errno == EINTR)
  734.       break; /* Got new interrupt */
  735.     printf("Got errno: %d from select.  Retrying..n",errno);
  736.     if (retry++ >= 3)
  737.     {
  738.       printf("Warning:  Interrupt of select() doesn't set errno!n");
  739.       break;
  740.     }
  741.   }
  742.   else /* This shouldn't happen */
  743.   {
  744.     if (!FD_ISSET(max_connection,&readFDs))
  745.     {
  746.       printf("Select interrupted, but errno not setn");
  747.       fflush(stdout);
  748.       if (retry++ >= 3)
  749. break;
  750.       continue;
  751.     }
  752.     VOID(getchar()); /* Somebody was playing */
  753.   }
  754. }
  755.       }
  756.     }
  757.     printf("Thread: %s  Slept for %d (%d) secn",my_thread_name(),
  758.    (int) (time((time_t*) 0)-start_time), wait_time); fflush(stdout);
  759.     thr_end_alarm(&got_alarm);
  760.     fflush(stdout);
  761.   }
  762.   pthread_mutex_lock(&LOCK_thread_count);
  763.   thread_count--;
  764.   VOID(pthread_cond_signal(&COND_thread_count)); /* Tell main we are ready */
  765.   pthread_mutex_unlock(&LOCK_thread_count);
  766.   free((gptr) arg);
  767.   return 0;
  768. }
  770. #ifdef USE_ONE_SIGNAL_HAND
  771. static sig_handler print_signal_warning(int sig)
  772. {
  773.   printf("Warning: Got signal %d from thread %sn",sig,my_thread_name());
  774.   fflush(stdout);
  775. #ifdef DONT_REMEMBER_SIGNAL
  776.   sigset(sig,print_signal_warning); /* int. thread system calls */
  777. #endif
  778.   if (sig == SIGALRM)
  779.     alarm(2); /* reschedule alarm */
  780. }
  781. #endif /* USE_ONE_SIGNAL_HAND */
  784. static void *signal_hand(void *arg __attribute__((unused)))
  785. {
  786.   sigset_t set;
  787.   int sig,error,err_count=0;;
  789.   my_thread_init();
  790.   pthread_detach_this_thread();
  791.   init_thr_alarm(10); /* Setup alarm handler */
  792.   pthread_mutex_lock(&LOCK_thread_count); /* Required by bsdi */
  793.   VOID(pthread_cond_signal(&COND_thread_count)); /* Tell main we are ready */
  794.   pthread_mutex_unlock(&LOCK_thread_count);
  796.   sigemptyset(&set); /* Catch all signals */
  797.   sigaddset(&set,SIGINT);
  798.   sigaddset(&set,SIGQUIT);
  799.   sigaddset(&set,SIGTERM);
  800. #if THR_CLIENT_ALARM != SIGHUP
  801.   sigaddset(&set,SIGHUP);
  802. #endif
  803. #ifdef SIGTSTP
  804.   sigaddset(&set,SIGTSTP);
  805. #endif
  806. #ifdef USE_ONE_SIGNAL_HAND
  807.   sigaddset(&set,THR_SERVER_ALARM); /* For alarms */
  808.   puts("Starting signal and alarm handling thread");
  809. #else
  810.   puts("Starting signal handling thread");
  811. #endif
  812.   printf("server alarm: %d  thread alarm: %dn",
  813.  THR_SERVER_ALARM,THR_CLIENT_ALARM);
  814.   DBUG_PRINT("info",("Starting signal and alarm handling thread"));
  815.   for(;;)
  816.   {
  817.     while ((error=my_sigwait(&set,&sig)) == EINTR)
  818.       printf("sigwait restartedn");
  819.     if (error)
  820.     {
  821.       fprintf(stderr,"Got error %d from sigwaitn",error);
  822.       if (err_count++ > 5)
  823. exit(1); /* Too many errors in test */
  824.       continue;
  825.     }
  826. #ifdef USE_ONE_SIGNAL_HAND
  827.     if (sig != THR_SERVER_ALARM)
  828. #endif
  829.       printf("Main thread: Got signal %dn",sig);
  830.     switch (sig) {
  831.     case SIGINT:
  832.     case SIGQUIT:
  833.     case SIGTERM:
  834.     case SIGHUP:
  835.       printf("Aborting nicelyn");
  836.       end_thr_alarm();
  837.       break;
  838. #ifdef SIGTSTP
  839.     case SIGTSTP:
  840.       printf("Abortingn");
  841.       exit(1);
  842.       return 0; /* Keep some compilers happy */
  843. #endif
  844. #ifdef USE_ONE_SIGNAL_HAND
  845.      case THR_SERVER_ALARM:
  846.        process_alarm(sig);
  847.       break;
  848. #endif
  849.     }
  850.   }
  851. }
  854. int main(int argc __attribute__((unused)),char **argv __attribute__((unused)))
  855. {
  856.   pthread_t tid;
  857.   pthread_attr_t thr_attr;
  858.   int i,*param,error;
  859.   sigset_t set;
  860.   MY_INIT(argv[0]);
  862.   if (argc > 1 && argv[1][0] == '-' && argv[1][1] == '#')
  863.     DBUG_PUSH(argv[1]+2);
  865.   pthread_mutex_init(&LOCK_thread_count,NULL);
  866.   pthread_cond_init(&COND_thread_count,NULL);
  868.   /* Start a alarm handling thread */
  869.   sigemptyset(&set);
  870.   sigaddset(&set,SIGINT);
  871.   sigaddset(&set,SIGQUIT);
  872.   sigaddset(&set,SIGTERM);
  873.   sigaddset(&set,SIGHUP);
  874.   signal(SIGTERM,SIG_DFL); /* If it's blocked by parent */
  875. #ifdef SIGTSTP
  876.   sigaddset(&set,SIGTSTP);
  877. #endif
  878.   sigaddset(&set,THR_SERVER_ALARM);
  879.   sigdelset(&set,THR_CLIENT_ALARM);
  880.   (void) pthread_sigmask(SIG_SETMASK,&set,NULL);
  881. #ifdef NOT_USED
  882.   sigemptyset(&set);
  883.   sigaddset(&set,THR_CLIENT_ALARM);
  884.   VOID(pthread_sigmask(SIG_UNBLOCK, &set, (sigset_t*) 0));
  885. #endif
  887.   pthread_attr_init(&thr_attr);
  888.   pthread_attr_setscope(&thr_attr,PTHREAD_SCOPE_PROCESS);
  889.   pthread_attr_setdetachstate(&thr_attr,PTHREAD_CREATE_DETACHED);
  890.   pthread_attr_setstacksize(&thr_attr,65536L);
  892.   /* Start signal thread and wait for it to start */
  893.   VOID(pthread_mutex_lock(&LOCK_thread_count));
  894.   pthread_create(&tid,&thr_attr,signal_hand,NULL);
  895.   VOID(pthread_cond_wait(&COND_thread_count,&LOCK_thread_count));
  896.   VOID(pthread_mutex_unlock(&LOCK_thread_count));
  897.   DBUG_PRINT("info",("signal thread created"));
  899.   thr_setconcurrency(3);
  900.   pthread_attr_setscope(&thr_attr,PTHREAD_SCOPE_PROCESS);
  901.   printf("Main thread: %sn",my_thread_name());
  902.   for (i=0 ; i < 2 ; i++)
  903.   {
  904.     param=(int*) malloc(sizeof(int));
  905.     *param= i;
  906.     pthread_mutex_lock(&LOCK_thread_count);
  907.     if ((error=pthread_create(&tid,&thr_attr,test_thread,(void*) param)))
  908.     {
  909.       printf("Can't create thread %d, error: %dn",i,error);
  910.       exit(1);
  911.     }
  912.     thread_count++;
  913.     pthread_mutex_unlock(&LOCK_thread_count);
  914.   }
  916.   pthread_attr_destroy(&thr_attr);
  917.   pthread_mutex_lock(&LOCK_thread_count);
  918.   while (thread_count)
  919.   {
  920.     VOID(pthread_cond_wait(&COND_thread_count,&LOCK_thread_count));
  921.     if (thread_count == 1)
  922.     {
  923.       printf("Calling end_thr_alarm. This should cancel the last threadn");
  924.       end_thr_alarm();
  925.     }
  926.   }
  927.   pthread_mutex_unlock(&LOCK_thread_count);
  928.   printf("Test succeededn");
  929.   return 0;
  930. }
  932. #else /* THREAD */
  934. int main(int argc __attribute__((unused)),char **argv __attribute__((unused)))
  935. {
  936. #ifndef THREAD
  937.   printf("thr_alarm disabled because we are not using threadsn");
  938. #else
  939.   printf("thr_alarm disabled with DONT_USE_THR_ALARMn");
  940. #endif
  941.   exit(1);
  942. }
  944. #endif /* THREAD */
  945. #endif /* MAIN */