more fixes for IM to substitude mysqld_safe in startup scripts

server-tools/instance-manager/commands.cc

@@ -274,10 +274,10 @@ int Show_instance_options::do_command(struct st_net *net,
         goto err;
     }
 
-    if (instance->options.is_guarded != NULL)
+    if (instance->options.nonguarded == NULL)
     {
       position= 0;
-      store_to_string(&send_buff, (char *) "guarded", &position);
+      store_to_string(&send_buff, (char *) "nonguarded", &position);
       store_to_string(&send_buff, "", &position);
       if (my_net_write(net, send_buff.buffer, (uint) position))
         goto err;
@@ -350,7 +350,7 @@ int Start_instance::execute(struct st_net *net, ulong connection_id)
     if (err_code= instance->start())
       return err_code;
 
-    if (instance->options.is_guarded != NULL)
+    if (instance->options.nonguarded == NULL)
         instance_map->guardian->guard(instance);
 
     net_send_ok(net, connection_id);
@@ -381,7 +381,7 @@ int Stop_instance::execute(struct st_net *net, ulong connection_id)
   }
   else
   {
-    if (instance->options.is_guarded != NULL)
+    if (instance->options.nonguarded == NULL)
         instance_map->guardian->
                stop_guard(instance);
     if ((err_code= instance->stop()))

server-tools/instance-manager/guardian.cc

@@ -46,6 +46,8 @@ Guardian_thread::Guardian_thread(Thread_registry &thread_registry_arg,
 {
   pthread_mutex_init(&LOCK_guardian, 0);
   pthread_cond_init(&COND_guardian, 0);
+  shutdown_guardian= FALSE;
+  is_stopped= FALSE;
   thread_registry.register_thread(&thread_info);
   init_alloc_root(&alloc, MEM_ROOT_BLOCK_SIZE, 0);
   guarded_instances= NULL;
@@ -65,6 +67,22 @@ Guardian_thread::~Guardian_thread()
 }
 
 
+void Guardian_thread::shutdown()
+{
+  pthread_mutex_lock(&LOCK_guardian);
+  shutdown_guardian= TRUE;
+  pthread_mutex_unlock(&LOCK_guardian);
+}
+
+
+void Guardian_thread::request_stop_instances()
+{
+  pthread_mutex_lock(&LOCK_guardian);
+  request_stop= TRUE;
+  pthread_mutex_unlock(&LOCK_guardian);
+}
+
+
 /*
   Run guardian thread
 
@@ -80,6 +98,7 @@ Guardian_thread::~Guardian_thread()
 void Guardian_thread::run()
 {
   Instance *instance;
+  int restart_retry= 100;
   LIST *loop;
   struct timespec timeout;
 
@@ -87,26 +106,68 @@ void Guardian_thread::run()
   pthread_mutex_lock(&LOCK_guardian);
 
 
-  while (!thread_registry.is_shutdown())
+  while (!shutdown_guardian)
   {
+    int status= 0;
     loop= guarded_instances;
     while (loop != NULL)
     {
-      instance= (Instance *) loop->data;
-      /* instance-> start already checks whether the instance is running */
-      if (instance->start() != ER_INSTANCE_ALREADY_STARTED)
-        log_info("guardian attempted to restart instance %s",
-                 instance->options.instance_name);
+      instance= ((GUARD_NODE *) loop->data)->instance;
+      if (!instance->is_running())
+      {
+        int state= 0;                           /* state of guardian */
+
+        if ((((GUARD_NODE *) loop->data)->crash_moment == 0))
+          state= 1;                             /* an instance just crashed */
+        else
+           if (time(NULL) - ((GUARD_NODE *) loop->data)->crash_moment <= 2)
+             /* try to restart an instance immediately */
+             state= 2;
+           else
+             state= 3;                          /* try to restart it */
+
+        if (state == 1)
+          ((GUARD_NODE *) loop->data)->crash_moment= time(NULL);
+
+        if ((state == 1) || (state == 2))
+        {
+          instance->start();
+          ((GUARD_NODE *) loop->data)->restart_counter++;
+          log_info("guardian: starting instance %s",
+                   instance->options.instance_name);
+        }
+        else
+        {
+          if ((status == ETIMEDOUT) &&
+             (((GUARD_NODE *) loop->data)->restart_counter < restart_retry))
+          {
+           instance->start();
+           ((GUARD_NODE *) loop->data)->restart_counter++;
+           log_info("guardian: starting instance %s",
+                    instance->options.instance_name);
+          }
+        }
+      }
+      else /* clear status fields */
+      {
+        ((GUARD_NODE *) loop->data)->restart_counter= 0;
+        ((GUARD_NODE *) loop->data)->crash_moment= 0;
+      }
       loop= loop->next;
     }
     move_to_list(&starting_instances, &guarded_instances);
     timeout.tv_sec= time(NULL) + monitoring_interval;
     timeout.tv_nsec= 0;
 
-    pthread_cond_timedwait(&COND_guardian, &LOCK_guardian, &timeout);
+    status= pthread_cond_timedwait(&COND_guardian, &LOCK_guardian, &timeout);
   }
 
   pthread_mutex_unlock(&LOCK_guardian);
+  if (request_stop)
+    stop_instances();
+  is_stopped= TRUE;
+  /* now, when the Guardian is stopped we can stop the IM */
+  thread_registry.request_shutdown();
   my_thread_end();
 }
 
@@ -119,7 +180,7 @@ int Guardian_thread::start()
   instance_map->lock();
   while ((instance= iterator.next()))
   {
-    if ((instance->options.is_guarded != NULL) && (instance->is_running()))
+    if ((instance->options.nonguarded == NULL))
       if (guard(instance))
         return 1;
   }
@@ -170,12 +231,18 @@ void Guardian_thread::move_to_list(LIST **from, LIST **to)
 int Guardian_thread::add_instance_to_list(Instance *instance, LIST **list)
 {
   LIST *node;
+  GUARD_NODE *content;
 
   node= (LIST *) alloc_root(&alloc, sizeof(LIST));
-  if (node == NULL)
+  content= (GUARD_NODE *) alloc_root(&alloc, sizeof(GUARD_NODE));
+
+  if ((node == NULL) || (content == NULL))
     return 1;
   /* we store the pointers to instances from the instance_map's MEM_ROOT */
-  node->data= (void *) instance;
+  content->instance= instance;
+  content->restart_counter= 0;
+  content->crash_moment= 0;
+  node->data= (void *) content;
 
   pthread_mutex_lock(&LOCK_guardian);
   *list= list_add(*list, node);
@@ -205,7 +272,7 @@ int Guardian_thread::stop_guard(Instance *instance)
       We compare only pointers, as we always use pointers from the
       instance_map's MEM_ROOT.
     */
-    if ((Instance *) node->data == instance)
+    if (((GUARD_NODE *) node->data)->instance == instance)
     {
       guarded_instances= list_delete(guarded_instances, node);
       pthread_mutex_unlock(&LOCK_guardian);
@@ -219,3 +286,21 @@ int Guardian_thread::stop_guard(Instance *instance)
   return 0;
 }
 
+int Guardian_thread::stop_instances()
+{
+  Instance *instance;
+  Instance_map::Iterator iterator(instance_map);
+
+  while ((instance= iterator.next()))
+  {
+    if ((instance->options.nonguarded == NULL))
+    {
+      if (stop_guard(instance))
+        return 1;
+      /* let us try to stop the server */
+      instance->stop();
+    }
+  }
+
+  return 0;
+}

server-tools/instance-manager/guardian.h

@@ -24,6 +24,7 @@
 #pragma interface
 #endif
 
+class Instance;
 class Instance_map;
 
 #include "thread_registry.h"
@@ -35,6 +36,13 @@ pthread_handler_decl(guardian, arg);
 
 C_MODE_END
 
+typedef struct st_guard_node
+{
+  Instance *instance;
+  uint restart_counter;
+  time_t crash_moment;
+} GUARD_NODE;
+
 
 struct Guardian_thread_args
 {
@@ -67,13 +75,17 @@ public:
   void run();
   int init();
   int start();
+  void shutdown();
+  void request_stop_instances();
   int guard(Instance *instance);
   int stop_guard(Instance *instance);
+  bool is_stopped;
 
 public:
   pthread_cond_t COND_guardian;
 
 private:
+  int stop_instances();
   int add_instance_to_list(Instance *instance, LIST **list);
   void move_to_list(LIST **from, LIST **to);
 
@@ -84,6 +96,13 @@ private:
   LIST *starting_instances;
   MEM_ROOT alloc;
   enum { MEM_ROOT_BLOCK_SIZE= 512 };
+  /* this variable is set to TRUE when we want to stop Guardian thread */
+  bool shutdown_guardian;
+  /*
+    This var is usually set together with shutdown_guardian. this way we
+    request guardian to shut down all instances before termination
+  */
+  bool request_stop;
 };
 
 #endif /* INCLUDES_MYSQL_INSTANCE_MANAGER_GUARDIAN_H */

server-tools/instance-manager/instance.cc

@@ -42,10 +42,16 @@
 
 int Instance::start()
 {
-  /* echk for the pidfile and remove it */
+  pid_t pid;
+
   if (!is_running())
   {
-    stop();
+    if ((pid= options.get_pid()) != 0)          /* check the pidfile */
+      if (options.unlink_pidfile())             /* remove stalled pidfile */
+        log_error("cannot remove pidfile for instance %i, this might be \
+                  since IM lacks permmissions or hasn't found the pidifle",
+                  options.instance_name);
+
     log_info("starting instance %s", options.instance_name);
     switch (pid= fork()) {
     case 0:
@@ -145,14 +151,17 @@ int Instance::stop()
 {
   pid_t pid;
   struct timespec timeout;
-  time_t waitchild= 35;                         /*  */
+  int waitchild= DEFAULT_SHUTDOWN_DELAY;
+
+  if (options.shutdown_delay != NULL)
+    waitchild= atoi(options.shutdown_delay);
 
   if ((pid= options.get_pid()) != 0)            /* get pid from pidfile */
   {
     /*
       If we cannot kill mysqld, then it has propably crashed.
       Let us try to remove staled pidfile and return succes as mysqld
-      is stopped
+      is probably stopped
     */
     if (kill(pid, SIGTERM))
     {
@@ -161,9 +170,6 @@ int Instance::stop()
                   since IM lacks permmissions or hasn't found the pidifle",
                   options.instance_name);
 
-      log_error("The instance %s has probably crashed or IM lacks permissions \
-                to kill it. in either case something seems to be wrong. \
-                Check your setup", options.instance_name);
       return 0;
     }
 
@@ -174,7 +180,7 @@ int Instance::stop()
     if (pthread_mutex_lock(&instance_map->pid_cond.LOCK_pid))
       goto err; /* perhaps this should be procecced differently */
 
-    while (options.get_pid() != 0)
+    while (options.get_pid() != 0)              /* while server isn't stopped */
     {
       int status;
 

server-tools/instance-manager/instance.h

@@ -41,11 +41,9 @@ public:
   int cleanup();
 
 public:
+  enum { DEFAULT_SHUTDOWN_DELAY= 35 };
   Instance_options options;
 
-  /* connection to the instance */
-  pid_t pid;
-
 private:
   /*
     Mutex protecting the instance. Currently we use it to avoid the

server-tools/instance-manager/instance_map.cc

@@ -82,7 +82,8 @@ static int process_option(void * ctx, const char *group, const char *option)
 
   map = (Instance_map*) ctx;
   if (strncmp(group, prefix, sizeof prefix) == 0 &&
-      (my_isdigit(default_charset_info, group[sizeof prefix])))
+      ((my_isdigit(default_charset_info, group[sizeof prefix]))
+       || group[sizeof(prefix)] == '\0'))
     {
       if ((instance= map->find(group, strlen(group))) == NULL)
       {
@@ -109,13 +110,9 @@ err_new_instance:
 C_MODE_END
 
 
-Instance_map::Instance_map(const char *default_mysqld_path_arg,
-                           const char *default_admin_user_arg,
-                           const char *default_admin_password_arg)
+Instance_map::Instance_map(const char *default_mysqld_path_arg)
 {
   mysqld_path= default_mysqld_path_arg;
-  user= default_admin_user_arg;
-  password= default_admin_password_arg;
 
   pthread_mutex_init(&LOCK_instance_map, 0);
 }
@@ -195,7 +192,7 @@ void Instance_map::complete_initialization()
   {
     instance= (Instance *) hash_element(&hash, i);
     instance->complete_initialization(this);
-    instance->options.complete_initialization(mysqld_path, user, password);
+    instance->options.complete_initialization(mysqld_path);
     i++;
   }
 }

server-tools/instance-manager/instance_map.h

@@ -71,9 +71,7 @@ public:
   int unlock();
   int init();
 
-  Instance_map(const char *default_mysqld_path_arg,
-               const char *default_admin_user_arg,
-               const char *default_admin_password_arg);
+  Instance_map(const char *default_mysqld_path_arg);
   ~Instance_map();
 
   /* loads options from config files */
@@ -85,9 +83,6 @@ public:
 
 public:
   const char *mysqld_path;
-  /* user an password to shutdown MySQL */
-  const char *user;
-  const char *password;
   Guardian_thread *guardian;
   /* structure used for syncronization reasons in the stop command */
   CHILD_COND pid_cond;

server-tools/instance-manager/instance_options.cc

@@ -113,9 +113,7 @@ pid_t Instance_options::get_pid()
 }
 
 
-int Instance_options::complete_initialization(const char *default_path,
-                                              const char *default_user,
-                                              const char *default_password)
+int Instance_options::complete_initialization(const char *default_path)
 {
   const char *tmp;
 
@@ -199,7 +197,8 @@ int Instance_options::add_option(const char* option)
     {"--bind-address=", 15, &mysqld_bind_address, SAVE_WHOLE_AND_ADD},
     {"--pid-file=", 11, &mysqld_pid_file, SAVE_WHOLE_AND_ADD},
     {"--mysqld-path=", 14, &mysqld_path, SAVE_VALUE},
-    {"--guarded", 9, &is_guarded, SAVE_WHOLE},
+    {"--nonguarded", 9, &nonguarded, SAVE_WHOLE},
+    {"--shutdown_delay", 9, &shutdown_delay, SAVE_VALUE},
     {NULL, 0, NULL, 0}
   };
   struct selected_options_st *selected_options;

server-tools/instance-manager/instance_options.h

@@ -38,14 +38,12 @@ class Instance_options
 public:
   Instance_options() :
     mysqld_socket(0), mysqld_datadir(0), mysqld_bind_address(0),
-    mysqld_pid_file(0), mysqld_port(0), mysqld_path(0), is_guarded(0),
+    mysqld_pid_file(0), mysqld_port(0), mysqld_path(0), nonguarded(0),
     filled_default_options(0)
   {}
   ~Instance_options();
   /* fills in argv */
-  int complete_initialization(const char *default_path,
-                              const char *default_user,
-                              const char *default_password);
+  int complete_initialization(const char *default_path);
 
   int add_option(const char* option);
   int init(const char *instance_name_arg);
@@ -71,7 +69,8 @@ public:
   uint instance_name_len;
   const char *instance_name;
   const char *mysqld_path;
-  const char *is_guarded;
+  const char *nonguarded;
+  const char *shutdown_delay;
   DYNAMIC_ARRAY options_array;
 private:
   int add_to_argv(const char *option);

server-tools/instance-manager/manager.cc

@@ -67,9 +67,7 @@ void manager(const Options &options)
   */
 
   User_map user_map;
-  Instance_map instance_map(options.default_mysqld_path,
-                            options.default_admin_user,
-                            options.default_admin_password);
+  Instance_map instance_map(options.default_mysqld_path);
   Guardian_thread guardian_thread(thread_registry,
                                   &instance_map,
                                   options.monitoring_interval);
@@ -181,8 +179,17 @@ void manager(const Options &options)
         pthread_cond_broadcast(&guardian_thread.COND_guardian);
       break;
       default:
-        thread_registry.deliver_shutdown();
-        shutdown_complete= TRUE;
+        if (!guardian_thread.is_stopped)
+        {
+          guardian_thread.request_stop_instances();
+          guardian_thread.shutdown();
+          pthread_cond_broadcast(&guardian_thread.COND_guardian);
+        }
+        else
+        {
+          thread_registry.deliver_shutdown();
+          shutdown_complete= TRUE;
+        }
       break;
     }
   }

server-tools/instance-manager/messages.cc

@@ -45,8 +45,8 @@ static const char *mysqld_error_message(unsigned sql_errno)
   case ER_BAD_INSTANCE_NAME:
     return "Bad instance name. Check that the instance with such a name exists";
   case ER_INSTANCE_IS_NOT_STARTED:
-    return "Cannot stop instance. Perhaps the instance is not started or you"
-           " have specified wrong username/password in the config file";
+    return "Cannot stop instance. Perhaps the instance is not started, or was started"
+            "manually, so IM cannot find the pidfile.";
   case ER_INSTANCE_ALREADY_STARTED:
     return "The instance is already started";
   case ER_CANNOT_START_INSTANCE:

server-tools/instance-manager/options.cc

@@ -35,8 +35,6 @@ const char *Options::pid_file_name= QUOTE(DEFAULT_PID_FILE_NAME);
 const char *Options::socket_file_name= QUOTE(DEFAULT_SOCKET_FILE_NAME);
 const char *Options::password_file_name= QUOTE(DEFAULT_PASSWORD_FILE_NAME);
 const char *Options::default_mysqld_path= QUOTE(DEFAULT_MYSQLD_PATH);
-const char *Options::default_admin_user= QUOTE(DEFAULT_USER);
-const char *Options::default_admin_password= QUOTE(DEFAULT_PASSWORD);
 const char *Options::bind_address= 0;              /* No default value */
 uint Options::monitoring_interval= DEFAULT_MONITORING_INTERVAL;
 uint Options::port_number= DEFAULT_PORT;
@@ -55,8 +53,6 @@ enum options {
   OPT_RUN_AS_SERVICE,
   OPT_USER,
   OPT_PASSWORD,
-  OPT_DEFAULT_ADMIN_USER,
-  OPT_DEFAULT_ADMIN_PASSWORD,
   OPT_MONITORING_INTERVAL,
   OPT_PORT,
   OPT_BIND_ADDRESS
@@ -98,18 +94,6 @@ static struct my_option my_long_options[] =
     (gptr *) &Options::default_mysqld_path, (gptr *) &Options::default_mysqld_path,
     0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
 
-  { "default-admin-user", OPT_DEFAULT_ADMIN_USER, "Username to shutdown MySQL"
-                                           " instances.",
-                   (gptr *) &Options::default_admin_user,
-                   (gptr *) &Options::default_admin_user,
-                   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
-
-  { "default-admin-password", OPT_DEFAULT_ADMIN_PASSWORD, "Password to"
-                                            "shutdown MySQL instances.",
-                   (gptr *) &Options::default_admin_password,
-                   (gptr *) &Options::default_admin_password,
-                   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
-
   { "monitoring-interval", OPT_MONITORING_INTERVAL, "Interval to monitor instances"
                                             " in seconds.",
                    (gptr *) &Options::monitoring_interval,

server-tools/instance-manager/thread_repository.cc

-/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
-
-#ifdef __GNUC__
-#pragma implementation 
-#endif
-
-#include "thread_repository.h"
-#include <assert.h>
-#include <signal.h>
-#include "log.h"
-
-
-/* Kick-off signal handler */
-  
-enum { THREAD_KICK_OFF_SIGNAL= SIGUSR2 };
-
-static void handle_signal(int __attribute__((unused)) sig_no)
-{
-}
-
-
-/*
-  TODO: think about moving signal information (now it's shutdown_in_progress)
-  to Thread_info. It will reduce contention and allow signal deliverence to
-  a particular thread, not to the whole worker crew 
-*/
-
-Thread_repository::Thread_repository() :
-  shutdown_in_progress(false)
-{
-  pthread_mutex_init(&LOCK_thread_repository, 0);
-  pthread_cond_init(&COND_thread_repository_is_empty, 0);
-
-  /* head is used by-value to simplify nodes inserting */
-  head.next= head.prev= &head;
-}
-
-
-Thread_repository::~Thread_repository()
-{
-  /* Check that no one uses the repository. */
-  pthread_mutex_lock(&LOCK_thread_repository);
-
-  /* All threads must unregister */
-  DBUG_ASSERT(head.next == &head);
-
-  pthread_mutex_unlock(&LOCK_thread_repository);
-  pthread_cond_destroy(&COND_thread_repository_is_empty);
-  pthread_mutex_destroy(&LOCK_thread_repository);
-}
-
-
-/*
-  
-  Set signal handler for kick-off thread, and insert a thread info to the
-  repository. New node is appended to the end of the list; head.prev always
-  points to the last node.
-*/
-
-void Thread_repository::register_thread(Thread_info *info)
-{
-  struct sigaction sa;
-  sa.sa_handler= handle_signal;
-  sa.sa_flags= 0;
-  sigemptyset(&sa.sa_mask);
-  sigaction(THREAD_KICK_OFF_SIGNAL, &sa, 0);
-
-  info->current_cond= 0;
-
-  pthread_mutex_lock(&LOCK_thread_repository);
-  info->next= &head;
-  info->prev= head.prev;
-  head.prev->next= info;
-  head.prev= info;
-  pthread_mutex_unlock(&LOCK_thread_repository);
-}
-
-
-/*
-  Unregister a thread from the repository and free Thread_info structure.
-  Every registered thread must unregister. Unregistering should be the last 
-  thing a thread is doing, otherwise it could have no time to finalize.
-*/
-
-void Thread_repository::unregister_thread(Thread_info *info)
-{
-  pthread_mutex_lock(&LOCK_thread_repository);
-  info->prev->next= info->next;
-  info->next->prev= info->prev;
-  if (head.next == &head)
-    pthread_cond_signal(&COND_thread_repository_is_empty);
-  pthread_mutex_unlock(&LOCK_thread_repository);
-}
-
-
-/*
-  Check whether shutdown is in progress, and if yes, return immidiately.
-  Else set info->current_cond and call pthread_cond_wait. When
-  pthread_cond_wait returns, unregister current cond and check the shutdown
-  status again.
-  RETURN VALUE
-    return value from pthread_cond_wait
-*/
-
-int Thread_repository::cond_wait(Thread_info *info, pthread_cond_t *cond,
-                                  pthread_mutex_t *mutex, bool *is_shutdown)
-{
-  pthread_mutex_lock(&LOCK_thread_repository);
-  *is_shutdown= shutdown_in_progress;
-  if (*is_shutdown)
-  {
-    pthread_mutex_unlock(&LOCK_thread_repository);
-    return 0;
-  }
-  info->current_cond= cond;
-  pthread_mutex_unlock(&LOCK_thread_repository);
-  /* sic: race condition here, cond can be signaled in deliver_shutdown */
-  int rc= pthread_cond_wait(cond, mutex);
-  pthread_mutex_lock(&LOCK_thread_repository);
-  info->current_cond= 0;
-  *is_shutdown= shutdown_in_progress;
-  pthread_mutex_unlock(&LOCK_thread_repository);
-  return rc;
-}
-
-
-/*
-  Deliver shutdown message to the workers crew.
-  As it's impossible to avoid all race conditions, we signal latecomers
-  again.
-*/
-
-void Thread_repository::deliver_shutdown()
-{
-  struct timespec shutdown_time;
-  set_timespec(shutdown_time, 1);
-  Thread_info *info;
-
-  pthread_mutex_lock(&LOCK_thread_repository);
-  shutdown_in_progress= true;
-  for (info= head.next; info != &head; info= info->next)
-  {
-    pthread_kill(info->thread_id, THREAD_KICK_OFF_SIGNAL);
-    /*
-      sic: race condition here, the thread may not yet fall into
-      pthread_cond_wait.
-    */
-    if (info->current_cond)
-      pthread_cond_signal(info->current_cond);
-  }
-  while (pthread_cond_timedwait(&COND_thread_repository_is_empty,
-                                &LOCK_thread_repository,
-                                &shutdown_time) != ETIMEDOUT &&
-         head.next != &head)
-    ;
-  /*
-    If previous signals did not reach some threads, they must be sleeping 
-    in pthread_cond_wait or a blocking syscall. Wake them up: 
-    every thread shall check signal variables after each syscall/cond_wait,
-    so this time everybody should be informed (presumably each worker can
-    get CPU during shutdown_time.)
-  */
-  for (info= head.next; info != &head; info= info->next)
-  {
-    pthread_kill(info->thread_id, THREAD_KICK_OFF_SIGNAL);
-    if (info->current_cond)
-      pthread_cond_signal(info->current_cond);
-  }
-  pthread_mutex_unlock(&LOCK_thread_repository);
-}
-

server-tools/instance-manager/thread_repository.h

-#ifndef INCLUDES_MYSQL_INSTANCE_MANAGER_THREAD_REPOSITORY_HH
-#define INCLUDES_MYSQL_INSTANCE_MANAGER_THREAD_REPOSITORY_HH
-/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
-
-/*
-  A multi-threaded application shall nicely work with signals.
-
-  This means it shall, first of all, shut down nicely on ``quit'' signals:
-  stop all running threads, cleanup and exit.
-
-  Note, that a thread can't be shut down nicely if it doesn't want to be.
-  That's why to perform clean shutdown, all threads consituting a process
-  must observe certain rules. Here we use the rules, described in Butenhof
-  book 'Programming with POSIX threads', namely:
-  - all user signals are handled in 'signal thread' in synchronous manner
-  (by means of sigwait). To guarantee that the signal thread is the only who
-  can receive user signals, all threads block them, and signal thread is 
-  the only who calls sigwait() with an apporpriate sigmask. 
-  To propogate a signal to the workers the signal thread sets
-  a variable, corresponding to the signal. Additionally the signal thread
-  sends each worker an internal signal (by means of pthread_kill) to kick it
-  out from possible blocking syscall, and possibly pthread_cond_signal if 
-  some thread is blocked in pthread_cond_[timed]wait.
-  - a worker handles only internal 'kick' signal (the handler does nothing).
-  In case when a syscall returns 'EINTR' the worker checks all
-  signal-related variables and behaves accordingly.
-  Also these variables shall be checked from time to time in long
-  CPU-bounded operations, and before/after pthread_cond_wait. (It's supposed
-  that a worker thread either waits in a syscall/conditional variable, or
-  computes something.)
-  - to guarantee signal deliverence, there should be some kind of feedback,
-  e. g. all workers shall account in the signal thread Thread Repository and
-  unregister from it on exit.
-  
-  Configuration reload (on SIGHUP) and thread timeouts/alarms can be handled
-  in manner, similar to ``quit'' signals.
-*/
-
-#ifdef __GNUC__
-#pragma interface
-#endif
-
-#include <my_global.h>
-#include <my_pthread.h>
-
-
-/*
-  Thread_info - repository entry for each worker thread
-  All entries comprise double-linked list like:
-     0 -- entry -- entry -- entry - 0
-  Double-linked list is used to unregister threads easy.
-*/
-
-class Thread_info
-{
-  pthread_cond_t *current_cond;
-  Thread_info *prev, *next;
-  pthread_t thread_id;
-  Thread_info() {}
-  friend class Thread_repository;
-public:
-  Thread_info(pthread_t thread_id_arg) : thread_id(thread_id_arg) {}
-};
-
-
-/*
-  Thread_repository - contains handles for each worker thread to deliver
-  signal information to workers.
-*/
-
-class Thread_repository
-{
-public:
-  Thread_repository();
-  ~Thread_repository();
-
-  void register_thread(Thread_info *info);
-  void unregister_thread(Thread_info *info);
-  void deliver_shutdown();
-  inline bool is_shutdown();
-  int cond_wait(Thread_info *info, pthread_cond_t *cond,
-                 pthread_mutex_t *mutex, bool *is_shutdown);
-private:
-  Thread_info head;
-  bool shutdown_in_progress;
-  pthread_mutex_t LOCK_thread_repository;
-  pthread_cond_t COND_thread_repository_is_empty;
-};
-
-
-inline bool Thread_repository::is_shutdown()
-{
-  pthread_mutex_lock(&LOCK_thread_repository);
-  bool res= shutdown_in_progress;
-  pthread_mutex_unlock(&LOCK_thread_repository);
-  return res;
-}
-
-#endif // INCLUDES_MYSQL_INSTANCE_MANAGER_THREAD_REPOSITORY_HH