← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/thr_alarm.c

  • Committer: Monty Taylor
  • Date: 2008-09-14 22:10:23 UTC
  • mto: This revision was merged to the branch mainline in revision 388.
  • Revision ID: monty@inaugust.com-20080914221023-otz8vuui590zp5yf
Got rid of libsqlcommon and some surious defines.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/thr_alarm.c
28
28
#include <sys/select.h>                         /* AIX needs this for fd_set */
29
29
#endif
30
30
 
31
 
#if TIME_WITH_SYS_TIME
32
 
# include <sys/time.h>
33
 
# include <time.h>
34
 
#else
35
 
# if HAVE_SYS_TIME_H
36
 
#  include <sys/time.h>
37
 
# else
38
 
#  include <time.h>
39
 
# endif
40
 
#endif  
41
 
 
42
 
 
43
31
#ifndef ETIME
44
32
#define ETIME ETIMEDOUT
45
33
#endif
46
34
 
47
 
uint32_t thr_client_alarm;
 
35
uint thr_client_alarm;
48
36
static int alarm_aborted=1;                     /* No alarm thread */
49
37
bool thr_alarm_inited= 0;
50
38
volatile bool alarm_thread_running= 0;
51
39
time_t next_alarm_expire_time= ~ (time_t) 0;
52
 
static RETSIGTYPE process_alarm_part2(int sig);
 
40
static sig_handler process_alarm_part2(int sig);
53
41
 
54
42
static pthread_mutex_t LOCK_alarm;
55
43
static pthread_cond_t COND_alarm;
56
44
static sigset_t full_signal_set;
57
45
static QUEUE alarm_queue;
58
 
static uint32_t max_used_alarms=0;
 
46
static uint max_used_alarms=0;
59
47
pthread_t alarm_thread;
60
48
 
61
49
#ifdef USE_ALARM_THREAD
65
53
#define reschedule_alarms() pthread_kill(alarm_thread,THR_SERVER_ALARM)
66
54
#endif
67
55
 
68
 
static RETSIGTYPE thread_alarm(int sig __attribute__((unused)));
 
56
static sig_handler thread_alarm(int sig __attribute__((unused)));
69
57
 
70
58
static int compare_uint32_t(void *not_used __attribute__((unused)),
71
 
                         unsigned char *a_ptr,unsigned char* b_ptr)
 
59
                         uchar *a_ptr,uchar* b_ptr)
72
60
{
73
61
  uint32_t a=*((uint32_t*) a_ptr),b= *((uint32_t*) b_ptr);
74
62
  return (a < b) ? -1  : (a == b) ? 0 : 1;
75
63
}
76
64
 
77
 
void init_thr_alarm(uint32_t max_alarms)
 
65
void init_thr_alarm(uint max_alarms)
78
66
{
79
67
  sigset_t s;
80
68
  alarm_aborted=0;
81
69
  next_alarm_expire_time= ~ (time_t) 0;
82
70
  init_queue(&alarm_queue,max_alarms+1,offsetof(ALARM,expire_time),0,
83
 
             compare_uint32_t,NULL);
 
71
             compare_uint32_t,NullS);
84
72
  sigfillset(&full_signal_set);                 /* Neaded to block signals */
85
73
  pthread_mutex_init(&LOCK_alarm,MY_MUTEX_INIT_FAST);
86
74
  pthread_cond_init(&COND_alarm,NULL);
106
94
    pthread_attr_setstacksize(&thr_attr,8196);
107
95
 
108
96
    my_pthread_attr_setprio(&thr_attr,100);     /* Very high priority */
109
 
    pthread_create(&alarm_thread,&thr_attr,alarm_handler,NULL);
110
 
    pthread_attr_destroy(&thr_attr);
 
97
    VOID(pthread_create(&alarm_thread,&thr_attr,alarm_handler,NULL));
 
98
    VOID(pthread_attr_destroy(&thr_attr));
111
99
  }
112
100
#elif defined(USE_ONE_SIGNAL_HAND)
113
101
  pthread_sigmask(SIG_BLOCK, &s, NULL);         /* used with sigwait() */
124
112
}
125
113
 
126
114
 
127
 
void resize_thr_alarm(uint32_t max_alarms)
 
115
void resize_thr_alarm(uint max_alarms)
128
116
{
129
117
  pthread_mutex_lock(&LOCK_alarm);
130
118
  /*
156
144
    when the alarm has been given
157
145
*/
158
146
 
159
 
bool thr_alarm(thr_alarm_t *alrm, uint32_t sec, ALARM *alarm_data)
 
147
bool thr_alarm(thr_alarm_t *alrm, uint sec, ALARM *alarm_data)
160
148
{
161
149
  time_t now;
162
150
#ifndef USE_ONE_SIGNAL_HAND
216
204
  alarm_data->alarmed=0;
217
205
  alarm_data->thread=    current_my_thread_var->pthread_self;
218
206
  alarm_data->thread_id= current_my_thread_var->id;
219
 
  queue_insert(&alarm_queue,(unsigned char*) alarm_data);
 
207
  queue_insert(&alarm_queue,(uchar*) alarm_data);
220
208
 
221
209
  /* Reschedule alarm if the current one has more than sec left */
222
210
  if (reschedule)
248
236
#ifndef USE_ONE_SIGNAL_HAND
249
237
  sigset_t old_mask;
250
238
#endif
251
 
  uint32_t i, found=0;
 
239
  uint i, found=0;
252
240
 
253
241
#ifndef USE_ONE_SIGNAL_HAND
254
242
  pthread_sigmask(SIG_BLOCK,&full_signal_set,&old_mask);
255
243
#endif
256
244
  pthread_mutex_lock(&LOCK_alarm);
257
245
 
258
 
  alarm_data= (ALARM*) ((unsigned char*) *alarmed - offsetof(ALARM,alarmed));
 
246
  alarm_data= (ALARM*) ((uchar*) *alarmed - offsetof(ALARM,alarmed));
259
247
  for (i=0 ; i < alarm_queue.elements ; i++)
260
248
  {
261
249
    if ((ALARM*) queue_element(&alarm_queue,i) == alarm_data)
262
250
    {
263
251
      queue_remove(&alarm_queue,i),MYF(0);
264
252
      if (alarm_data->malloced)
265
 
        free((unsigned char*) alarm_data);
 
253
        my_free((uchar*) alarm_data,MYF(0));
266
254
      found++;
267
255
      break;
268
256
    }
289
277
  every second.
290
278
*/
291
279
 
292
 
RETSIGTYPE process_alarm(int sig __attribute__((unused)))
 
280
sig_handler process_alarm(int sig __attribute__((unused)))
293
281
{
294
282
  sigset_t old_mask;
295
283
 
299
287
#if defined(MAIN) && !defined(__bsdi__)
300
288
    printf("thread_alarm in process_alarm\n"); fflush(stdout);
301
289
#endif
302
 
#ifndef HAVE_BSD_SIGNALS
 
290
#ifdef DONT_REMEMBER_SIGNAL
303
291
    my_sigset(thr_client_alarm, process_alarm); /* int. thread system calls */
304
292
#endif
305
293
    return;
311
299
#endif
312
300
  process_alarm_part2(sig);
313
301
#ifndef USE_ALARM_THREAD
314
 
#if !defined(HAVE_BSD_SIGNALS) && !defined(USE_ONE_SIGNAL_HAND)
 
302
#if defined(DONT_REMEMBER_SIGNAL) && !defined(USE_ONE_SIGNAL_HAND)
315
303
  my_sigset(THR_SERVER_ALARM,process_alarm);
316
304
#endif
317
305
  pthread_mutex_unlock(&LOCK_alarm);
321
309
}
322
310
 
323
311
 
324
 
static RETSIGTYPE process_alarm_part2(int sig __attribute__((unused)))
 
312
static sig_handler process_alarm_part2(int sig __attribute__((unused)))
325
313
{
326
314
  ALARM *alarm_data;
327
315
 
332
320
  {
333
321
    if (alarm_aborted)
334
322
    {
335
 
      uint32_t i;
 
323
      uint i;
336
324
      for (i=0 ; i < alarm_queue.elements ;)
337
325
      {
338
326
        alarm_data=(ALARM*) queue_element(&alarm_queue,i);
460
448
 
461
449
void thr_alarm_kill(my_thread_id thread_id)
462
450
{
463
 
  uint32_t i;
 
451
  uint i;
464
452
  if (alarm_aborted)
465
453
    return;
466
454
  pthread_mutex_lock(&LOCK_alarm);
470
458
    {
471
459
      ALARM *tmp=(ALARM*) queue_remove(&alarm_queue,i);
472
460
      tmp->expire_time=0;
473
 
      queue_insert(&alarm_queue,(unsigned char*) tmp);
 
461
      queue_insert(&alarm_queue,(uchar*) tmp);
474
462
      reschedule_alarms();
475
463
      break;
476
464
    }
501
489
*/
502
490
 
503
491
 
504
 
static RETSIGTYPE thread_alarm(int sig)
 
492
static sig_handler thread_alarm(int sig)
505
493
{
506
494
#ifdef MAIN
507
495
  printf("thread_alarm\n"); fflush(stdout);
508
496
#endif
509
 
#ifndef HAVE_BSD_SIGNALS
 
497
#ifdef DONT_REMEMBER_SIGNAL
510
498
  my_sigset(sig,thread_alarm);          /* int. thread system calls */
511
499
#endif
512
500
}
590
578
 
591
579
static pthread_cond_t COND_thread_count;
592
580
static pthread_mutex_t LOCK_thread_count;
593
 
static uint32_t thread_count;
 
581
static uint thread_count;
594
582
 
595
583
#ifdef HPUX10
596
584
typedef int * fd_set_ptr;
637
625
      if (wait_time == 7)
638
626
      {                                         /* Simulate alarm-miss */
639
627
        fd_set readFDs;
640
 
        uint32_t max_connection=fileno(stdin);
 
628
        uint max_connection=fileno(stdin);
641
629
        FD_ZERO(&readFDs);
642
630
        FD_SET(max_connection,&readFDs);
643
631
        retry=0;
666
654
                break;
667
655
              continue;
668
656
            }
669
 
            getchar();                  /* Somebody was playing */
 
657
            VOID(getchar());                    /* Somebody was playing */
670
658
          }
671
659
        }
672
660
      }
678
666
  }
679
667
  pthread_mutex_lock(&LOCK_thread_count);
680
668
  thread_count--;
681
 
  pthread_cond_signal(&COND_thread_count); /* Tell main we are ready */
 
669
  VOID(pthread_cond_signal(&COND_thread_count)); /* Tell main we are ready */
682
670
  pthread_mutex_unlock(&LOCK_thread_count);
683
 
  free((unsigned char*) arg);
 
671
  free((uchar*) arg);
684
672
  return 0;
685
673
}
686
674
 
687
675
#ifdef USE_ONE_SIGNAL_HAND
688
 
static RETSIGTYPE print_signal_warning(int sig)
 
676
static sig_handler print_signal_warning(int sig)
689
677
{
690
678
  printf("Warning: Got signal %d from thread %s\n",sig,my_thread_name());
691
679
  fflush(stdout);
692
 
#ifndef HAVE_BSD_SIGNALS
 
680
#ifdef DONT_REMEMBER_SIGNAL
693
681
  my_sigset(sig,print_signal_warning);          /* int. thread system calls */
694
682
#endif
695
683
  if (sig == SIGALRM)
707
695
  pthread_detach_this_thread();
708
696
  init_thr_alarm(10);                           /* Setup alarm handler */
709
697
  pthread_mutex_lock(&LOCK_thread_count);       /* Required by bsdi */
710
 
  pthread_cond_signal(&COND_thread_count); /* Tell main we are ready */
 
698
  VOID(pthread_cond_signal(&COND_thread_count)); /* Tell main we are ready */
711
699
  pthread_mutex_unlock(&LOCK_thread_count);
712
700
 
713
701
  sigemptyset(&set);                            /* Catch all signals */
793
781
#ifdef NOT_USED
794
782
  sigemptyset(&set);
795
783
  sigaddset(&set, thr_client_alarm);
796
 
  pthread_sigmask(SIG_UNBLOCK, &set, (sigset_t*) 0);
 
784
  VOID(pthread_sigmask(SIG_UNBLOCK, &set, (sigset_t*) 0));
797
785
#endif
798
786
 
799
787
  pthread_attr_init(&thr_attr);
802
790
  pthread_attr_setstacksize(&thr_attr,65536L);
803
791
 
804
792
  /* Start signal thread and wait for it to start */
805
 
  pthread_mutex_lock(&LOCK_thread_count);
 
793
  VOID(pthread_mutex_lock(&LOCK_thread_count));
806
794
  pthread_create(&tid,&thr_attr,signal_hand,NULL);
807
 
  pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
808
 
  pthread_mutex_unlock(&LOCK_thread_count);
 
795
  VOID(pthread_cond_wait(&COND_thread_count,&LOCK_thread_count));
 
796
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
809
797
 
810
798
  thr_setconcurrency(3);
811
799
  pthread_attr_setscope(&thr_attr,PTHREAD_SCOPE_PROCESS);
832
820
         alarm_info.next_alarm_time);
833
821
  while (thread_count)
834
822
  {
835
 
    pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
 
823
    VOID(pthread_cond_wait(&COND_thread_count,&LOCK_thread_count));
836
824
    if (thread_count == 1)
837
825
    {
838
826
      printf("Calling end_thr_alarm. This should cancel the last thread\n");