kernel/cpr/cpr_uthread.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #pragma ident   "%Z%%M% %I%     %E% SMI"
  27
  28 #include <sys/types.h>
  29 #include <sys/thread.h>
  30 #include <sys/conf.h>
  31 #include <sys/cpuvar.h>
  32 #include <sys/cpr.h>
  33 #include <sys/user.h>
  34 #include <sys/cmn_err.h>
  35 #include <sys/callb.h>
  36
  37 extern void utstop_init(void);
  38 extern void add_one_utstop(void);
  39 extern void utstop_timedwait(long ticks);
  40
  41 static void cpr_stop_user(int);
  42 static int cpr_check_user_threads(void);
  43
  44 /*
  45  * CPR user thread related support routines
  46  */
  47 void
  48 cpr_signal_user(int sig)
  49 {
  50 /*
  51  * The signal SIGTHAW and SIGFREEZE cannot be sent to every thread yet
  52  * since openwin is catching every signal and default action is to exit.
  53  * We also need to implement the true SIGFREEZE and SIGTHAW to stop threads.
  54  */
  55         struct proc *p;
  56
  57         mutex_enter(&pidlock);
  58
  59         for (p = practive; p; p = p->p_next) {
  60                 /* only user threads */
  61                 if (p->p_exec == NULL || p->p_stat == SZOMB ||
  62                     p == proc_init || p == ttoproc(curthread))
  63                         continue;
  64
  65                 mutex_enter(&p->p_lock);
  66                 sigtoproc(p, NULL, sig);
  67                 mutex_exit(&p->p_lock);
  68         }
  69         mutex_exit(&pidlock);
  70
  71         DELAY(MICROSEC);
  72 }
  73
  74 /* max wait time for user thread stop */
  75 #define CPR_UTSTOP_WAIT         hz
  76 #define CPR_UTSTOP_RETRY        4
  77 static int count;
  78
  79 int
  80 cpr_stop_user_threads()
  81 {
  82         utstop_init();
  83
  84         count = 0;
  85         do {
  86                 if (++count > CPR_UTSTOP_RETRY)
  87                         return (ESRCH);
  88                 cpr_stop_user(count * count * CPR_UTSTOP_WAIT);
  89         } while (cpr_check_user_threads());
  90
  91         return (0);
  92 }
  93
  94 /*
  95  * This routine tries to stop all user threads before we get rid of all
  96  * its pages.It goes through allthreads list and set the TP_CHKPT flag
  97  * for all user threads and make them runnable. If all of the threads
  98  * can be stopped within the max wait time, CPR will proceed. Otherwise
  99  * CPR is aborted after a few of similiar retries.
 100  */
 101 static void
 102 cpr_stop_user(int wait)
 103 {
 104         kthread_id_t tp;
 105         proc_t *p;
 106
 107         /* The whole loop below needs to be atomic */
 108         mutex_enter(&pidlock);
 109
 110         /* faster this way */
 111         tp = curthread->t_next;
 112         do {
 113                 /* kernel threads will be handled later */
 114                 p = ttoproc(tp);
 115                 if (p->p_as == &kas || p->p_stat == SZOMB)
 116                         continue;
 117
 118                 /*
 119                  * If the thread is stopped (by CPR) already, do nothing;
 120                  * if running, mark TP_CHKPT;
 121                  * if sleeping normally, mark TP_CHKPT and setrun;
 122                  * if sleeping non-interruptable, mark TP_CHKPT only for now;
 123                  * if sleeping with t_wchan0 != 0 etc, virtually stopped,
 124                  * do nothing.
 125                  */
 126
 127                 /* p_lock is needed for modifying t_proc_flag */
 128                 mutex_enter(&p->p_lock);
 129                 thread_lock(tp); /* needed to check CPR_ISTOPPED */
 130
 131                 if (tp->t_state == TS_STOPPED) {
 132                         /*
 133                          * if already stopped by other reasons, add this new
 134                          * reason to it.
 135                          */
 136                         if (tp->t_schedflag & TS_RESUME)
 137                                 tp->t_schedflag &= ~TS_RESUME;
 138                 } else {
 139
 140                         tp->t_proc_flag |= TP_CHKPT;
 141
 142                         thread_unlock(tp);
 143                         mutex_exit(&p->p_lock);
 144                         add_one_utstop();
 145                         mutex_enter(&p->p_lock);
 146                         thread_lock(tp);
 147
 148                         aston(tp);
 149
 150                         if (ISWAKEABLE(tp) || ISWAITING(tp)) {
 151                                 setrun_locked(tp);
 152                         }
 153                 }
 154                 /*
 155                  * force the thread into the kernel if it is not already there.
 156                  */
 157                 if (tp->t_state == TS_ONPROC && tp->t_cpu != CPU)
 158                         poke_cpu(tp->t_cpu->cpu_id);
 159                 thread_unlock(tp);
 160                 mutex_exit(&p->p_lock);
 161
 162         } while ((tp = tp->t_next) != curthread);
 163         mutex_exit(&pidlock);
 164
 165         utstop_timedwait(wait);
 166 }
 167
 168 /*
 169  * Checks and makes sure all user threads are stopped
 170  */
 171 static int
 172 cpr_check_user_threads()
 173 {
 174         kthread_id_t tp;
 175         int rc = 0;
 176
 177         mutex_enter(&pidlock);
 178         tp = curthread->t_next;
 179         do {
 180                 if (ttoproc(tp)->p_as == &kas || ttoproc(tp)->p_stat == SZOMB)
 181                         continue;
 182
 183                 thread_lock(tp);
 184                 /*
 185                  * make sure that we are off all the queues and in a stopped
 186                  * state.
 187                  */
 188                 if (!CPR_ISTOPPED(tp)) {
 189                         thread_unlock(tp);
 190                         mutex_exit(&pidlock);
 191
 192                         if (count == CPR_UTSTOP_RETRY) {
 193                         CPR_DEBUG(CPR_DEBUG1, "Suspend failed: "
 194                             "cannot stop uthread\n");
 195                         cpr_err(CE_WARN, "Suspend cannot stop "
 196                             "process %s (%p:%x).",
 197                             ttoproc(tp)->p_user.u_psargs, (void *)tp,
 198                             tp->t_state);
 199                         cpr_err(CE_WARN, "Process may be waiting for"
 200                             " network request, please try again.");
 201                         }
 202
 203                         CPR_DEBUG(CPR_DEBUG2, "cant stop t=%p state=%x pfg=%x "
 204                             "sched=%x\n", (void *)tp, tp->t_state,
 205                             tp->t_proc_flag, tp->t_schedflag);
 206                         CPR_DEBUG(CPR_DEBUG2, "proc %p state=%x pid=%d\n",
 207                             (void *)ttoproc(tp), ttoproc(tp)->p_stat,
 208                             ttoproc(tp)->p_pidp->pid_id);
 209                         return (1);
 210                 }
 211                 thread_unlock(tp);
 212
 213         } while ((tp = tp->t_next) != curthread && rc == 0);
 214
 215         mutex_exit(&pidlock);
 216         return (0);
 217 }
 218
 219
 220 /*
 221  * start all threads that were stopped for checkpoint.
 222  */
 223 void
 224 cpr_start_user_threads()
 225 {
 226         kthread_id_t tp;
 227         proc_t *p;
 228
 229         mutex_enter(&pidlock);
 230         tp = curthread->t_next;
 231         do {
 232                 p = ttoproc(tp);
 233                 /*
 234                  * kernel threads are callback'ed rather than setrun.
 235                  */
 236                 if (ttoproc(tp)->p_as == &kas) continue;
 237                 /*
 238                  * t_proc_flag should have been cleared. Just to make sure here
 239                  */
 240                 mutex_enter(&p->p_lock);
 241                 tp->t_proc_flag &= ~TP_CHKPT;
 242                 mutex_exit(&p->p_lock);
 243
 244                 thread_lock(tp);
 245                 if (CPR_ISTOPPED(tp)) {
 246
 247                         /*
 248                          * put it back on the runq
 249                          */
 250                         tp->t_schedflag |= TS_RESUME;
 251                         setrun_locked(tp);
 252                 }
 253                 thread_unlock(tp);
 254                 /*
 255                  * DEBUG - Keep track of current and next thread pointer.
 256                  */
 257         } while ((tp = tp->t_next) != curthread);
 258
 259         mutex_exit(&pidlock);
 260 }
 261
 262
 263 /*
 264  * re/start kernel threads
 265  */
 266 void
 267 cpr_start_kernel_threads(void)
 268 {
 269         CPR_DEBUG(CPR_DEBUG1, "starting kernel daemons...");
 270         (void) callb_execute_class(CB_CL_CPR_DAEMON, CB_CODE_CPR_RESUME);
 271         CPR_DEBUG(CPR_DEBUG1, "done\n");
 272
 273         /* see table lock below */
 274         callb_unlock_table();
 275 }
 276
 277
 278 /*
 279  * Stop kernel threads by using the callback mechanism.  If any thread
 280  * cannot be stopped, return failure.
 281  */
 282 int
 283 cpr_stop_kernel_threads(void)
 284 {
 285         caddr_t name;
 286
 287         callb_lock_table();     /* Note: we unlock the table in resume. */
 288
 289         CPR_DEBUG(CPR_DEBUG1, "stopping kernel daemons...");
 290         if ((name = callb_execute_class(CB_CL_CPR_DAEMON,
 291             CB_CODE_CPR_CHKPT)) != NULL) {
 292                 cpr_err(CE_WARN,
 293                     "Could not stop \"%s\" kernel thread.  "
 294                     "Please try again later.", name);
 295                 return (EBUSY);
 296         }
 297
 298         CPR_DEBUG(CPR_DEBUG1, ("done\n"));
 299         return (0);
 300 }
 301
 302 /*
 303  * Check to see that kernel threads are stopped.
 304  * This should be called while CPU's are paused, and the caller is
 305  * effectively running single user, or else we are virtually guaranteed
 306  * to fail.  The routine should not ASSERT on the paused state or spl
 307  * level, as there may be a use for this to verify that things are running
 308  * again.
 309  */
 310 int
 311 cpr_threads_are_stopped(void)
 312 {
 313         caddr_t name;
 314         kthread_id_t tp;
 315         proc_t *p;
 316
 317         /*
 318          * We think we stopped all the kernel threads.  Just in case
 319          * someone is not playing by the rules, take a spin through
 320          * the threadlist and see if we can account for everybody.
 321          */
 322         mutex_enter(&pidlock);
 323         tp = curthread->t_next;
 324         do {
 325                 p = ttoproc(tp);
 326                 if (p->p_as != &kas)
 327                         continue;
 328
 329                 if (tp->t_flag & T_INTR_THREAD)
 330                         continue;
 331
 332                 if (! callb_is_stopped(tp, &name)) {
 333                         mutex_exit(&pidlock);
 334                         cpr_err(CE_WARN,
 335                             "\"%s\" kernel thread not stopped.", name);
 336                         return (EBUSY);
 337                 }
 338         } while ((tp = tp->t_next) != curthread);
 339
 340         mutex_exit(&pidlock);
 341         return (0);
 342 }