kernel/os/callb.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 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #include <sys/param.h>
  27 #include <sys/t_lock.h>
  28 #include <sys/types.h>
  29 #include <sys/time.h>
  30 #include <sys/sysmacros.h>
  31 #include <sys/systm.h>
  32 #include <sys/cpuvar.h>
  33 #include <sys/user.h>
  34 #include <sys/proc.h>
  35 #include <sys/callb.h>
  36 #include <sys/kmem.h>
  37 #include <sys/cmn_err.h>
  38 #include <sys/swap.h>
  39 #include <sys/vmsystm.h>
  40 #include <sys/class.h>
  41 #include <sys/debug.h>
  42 #include <sys/thread.h>
  43 #include <sys/kobj.h>
  44 #include <sys/ddi.h>    /* for delay() */
  45 #include <sys/taskq.h>  /* For TASKQ_NAMELEN */
  46
  47 #define CB_MAXNAME      TASKQ_NAMELEN
  48
  49 /*
  50  * The callb mechanism provides generic event scheduling/echoing.
  51  * A callb function is registered and called on behalf of the event.
  52  */
  53 typedef struct callb {
  54         struct callb    *c_next;        /* next in class or on freelist */
  55         kthread_id_t    c_thread;       /* ptr to caller's thread struct */
  56         char            c_flag;         /* info about the callb state */
  57         uchar_t         c_class;        /* this callb's class */
  58         kcondvar_t      c_done_cv;      /* signal callb completion */
  59         boolean_t       (*c_func)();    /* cb function: returns true if ok */
  60         void            *c_arg;         /* arg to c_func */
  61         char            c_name[CB_MAXNAME+1]; /* debug:max func name length */
  62 } callb_t;
  63
  64 /*
  65  * callb c_flag bitmap definitions
  66  */
  67 #define CALLB_FREE              0x0
  68 #define CALLB_TAKEN             0x1
  69 #define CALLB_EXECUTING         0x2
  70
  71 /*
  72  * Basic structure for a callb table.
  73  * All callbs are organized into different class groups described
  74  * by ct_class array.
  75  * The callbs within a class are single-linked and normally run by a
  76  * serial execution.
  77  */
  78 typedef struct callb_table {
  79         kmutex_t ct_lock;               /* protect all callb states */
  80         callb_t *ct_freelist;           /* free callb structures */
  81         int     ct_busy;                /* != 0 prevents additions */
  82         kcondvar_t ct_busy_cv;          /* to wait for not busy    */
  83         int     ct_ncallb;              /* num of callbs allocated */
  84         callb_t *ct_first_cb[NCBCLASS]; /* ptr to 1st callb in a class */
  85 } callb_table_t;
  86
  87 int callb_timeout_sec = CPR_KTHREAD_TIMEOUT_SEC;
  88
  89 static callb_id_t callb_add_common(boolean_t (*)(void *, int),
  90     void *, int, char *, kthread_id_t);
  91
  92 static callb_table_t callb_table;       /* system level callback table */
  93 static callb_table_t *ct = &callb_table;
  94 static kmutex_t callb_safe_mutex;
  95 callb_cpr_t     callb_cprinfo_safe = {
  96         &callb_safe_mutex, CALLB_CPR_ALWAYS_SAFE, 0, 0, 0 };
  97
  98 /*
  99  * Init all callb tables in the system.
 100  */
 101 void
 102 callb_init()
 103 {
 104         callb_table.ct_busy = 0;        /* mark table open for additions */
 105         mutex_init(&callb_safe_mutex, NULL, MUTEX_DEFAULT, NULL);
 106         mutex_init(&callb_table.ct_lock, NULL, MUTEX_DEFAULT, NULL);
 107 }
 108
 109 /*
 110  * callout_add() is called to register func() be called later.
 111  */
 112 static callb_id_t
 113 callb_add_common(boolean_t (*func)(void *arg, int code),
 114     void *arg, int class, char *name, kthread_id_t t)
 115 {
 116         callb_t *cp;
 117
 118         ASSERT(class < NCBCLASS);
 119
 120         mutex_enter(&ct->ct_lock);
 121         while (ct->ct_busy)
 122                 cv_wait(&ct->ct_busy_cv, &ct->ct_lock);
 123         if ((cp = ct->ct_freelist) == NULL) {
 124                 ct->ct_ncallb++;
 125                 cp = (callb_t *)kmem_zalloc(sizeof (callb_t), KM_SLEEP);
 126         }
 127         ct->ct_freelist = cp->c_next;
 128         cp->c_thread = t;
 129         cp->c_func = func;
 130         cp->c_arg = arg;
 131         cp->c_class = (uchar_t)class;
 132         cp->c_flag |= CALLB_TAKEN;
 133 #ifdef DEBUG
 134         if (strlen(name) > CB_MAXNAME)
 135                 cmn_err(CE_WARN, "callb_add: name of callback function '%s' "
 136                     "too long -- truncated to %d chars",
 137                     name, CB_MAXNAME);
 138 #endif
 139         (void) strncpy(cp->c_name, name, CB_MAXNAME);
 140         cp->c_name[CB_MAXNAME] = '\0';
 141
 142         /*
 143          * Insert the new callb at the head of its class list.
 144          */
 145         cp->c_next = ct->ct_first_cb[class];
 146         ct->ct_first_cb[class] = cp;
 147
 148         mutex_exit(&ct->ct_lock);
 149         return ((callb_id_t)cp);
 150 }
 151
 152 /*
 153  * The default function to add an entry to the callback table.  Since
 154  * it uses curthread as the thread identifier to store in the table,
 155  * it should be used for the normal case of a thread which is calling
 156  * to add ITSELF to the table.
 157  */
 158 callb_id_t
 159 callb_add(boolean_t (*func)(void *arg, int code),
 160     void *arg, int class, char *name)
 161 {
 162         return (callb_add_common(func, arg, class, name, curthread));
 163 }
 164
 165 /*
 166  * A special version of callb_add() above for use by threads which
 167  * might be adding an entry to the table on behalf of some other
 168  * thread (for example, one which is constructed but not yet running).
 169  * In this version the thread id is an argument.
 170  */
 171 callb_id_t
 172 callb_add_thread(boolean_t (*func)(void *arg, int code),
 173     void *arg, int class, char *name, kthread_id_t t)
 174 {
 175         return (callb_add_common(func, arg, class, name, t));
 176 }
 177
 178 /*
 179  * callout_delete() is called to remove an entry identified by id
 180  * that was originally placed there by a call to callout_add().
 181  * return -1 if fail to delete a callb entry otherwise return 0.
 182  */
 183 int
 184 callb_delete(callb_id_t id)
 185 {
 186         callb_t **pp;
 187         callb_t *me = (callb_t *)id;
 188
 189         mutex_enter(&ct->ct_lock);
 190
 191         for (;;) {
 192                 pp = &ct->ct_first_cb[me->c_class];
 193                 while (*pp != NULL && *pp != me)
 194                         pp = &(*pp)->c_next;
 195
 196 #ifdef DEBUG
 197                 if (*pp != me) {
 198                         cmn_err(CE_WARN, "callb delete bogus entry 0x%p",
 199                             (void *)me);
 200                         mutex_exit(&ct->ct_lock);
 201                         return (-1);
 202                 }
 203 #endif /* DEBUG */
 204
 205                 /*
 206                  * It is not allowed to delete a callb in the middle of
 207                  * executing otherwise, the callb_execute() will be confused.
 208                  */
 209                 if (!(me->c_flag & CALLB_EXECUTING))
 210                         break;
 211
 212                 cv_wait(&me->c_done_cv, &ct->ct_lock);
 213         }
 214         /* relink the class list */
 215         *pp = me->c_next;
 216
 217         /* clean up myself and return the free callb to the head of freelist */
 218         me->c_flag = CALLB_FREE;
 219         me->c_next = ct->ct_freelist;
 220         ct->ct_freelist = me;
 221
 222         mutex_exit(&ct->ct_lock);
 223         return (0);
 224 }
 225
 226 /*
 227  * class:       indicates to execute all callbs in the same class;
 228  * code:        optional argument for the callb functions.
 229  * return:       = 0: success
 230  *              != 0: ptr to string supplied when callback was registered
 231  */
 232 void *
 233 callb_execute_class(int class, int code)
 234 {
 235         callb_t *cp;
 236         void *ret = NULL;
 237
 238         ASSERT(class < NCBCLASS);
 239
 240         mutex_enter(&ct->ct_lock);
 241
 242         for (cp = ct->ct_first_cb[class];
 243             cp != NULL && ret == 0; cp = cp->c_next) {
 244                 while (cp->c_flag & CALLB_EXECUTING)
 245                         cv_wait(&cp->c_done_cv, &ct->ct_lock);
 246                 /*
 247                  * cont if the callb is deleted while we're sleeping
 248                  */
 249                 if (cp->c_flag == CALLB_FREE)
 250                         continue;
 251                 cp->c_flag |= CALLB_EXECUTING;
 252
 253 #ifdef CALLB_DEBUG
 254                 printf("callb_execute: name=%s func=%p arg=%p\n",
 255                     cp->c_name, (void *)cp->c_func, (void *)cp->c_arg);
 256 #endif /* CALLB_DEBUG */
 257
 258                 mutex_exit(&ct->ct_lock);
 259                 /* If callback function fails, pass back client's name */
 260                 if (!(*cp->c_func)(cp->c_arg, code))
 261                         ret = cp->c_name;
 262                 mutex_enter(&ct->ct_lock);
 263
 264                 cp->c_flag &= ~CALLB_EXECUTING;
 265                 cv_broadcast(&cp->c_done_cv);
 266         }
 267         mutex_exit(&ct->ct_lock);
 268         return (ret);
 269 }
 270
 271 /*
 272  * callers make sure no recursive entries to this func.
 273  * dp->cc_lockp is registered by callb_add to protect callb_cpr_t structure.
 274  *
 275  * When calling to stop a kernel thread (code == CB_CODE_CPR_CHKPT) we
 276  * use a cv_timedwait() in case the kernel thread is blocked.
 277  *
 278  * Note that this is a generic callback handler for daemon CPR and
 279  * should NOT be changed to accommodate any specific requirement in a daemon.
 280  * Individual daemons that require changes to the handler shall write
 281  * callback routines in their own daemon modules.
 282  */
 283 boolean_t
 284 callb_generic_cpr(void *arg, int code)
 285 {
 286         callb_cpr_t *cp = (callb_cpr_t *)arg;
 287         clock_t ret = 0;                        /* assume success */
 288
 289         mutex_enter(cp->cc_lockp);
 290
 291         switch (code) {
 292         case CB_CODE_CPR_CHKPT:
 293                 cp->cc_events |= CALLB_CPR_START;
 294 #ifdef CPR_NOT_THREAD_SAFE
 295                 while (!(cp->cc_events & CALLB_CPR_SAFE))
 296                         /* cv_timedwait() returns -1 if it times out. */
 297                         if ((ret = cv_reltimedwait(&cp->cc_callb_cv,
 298                             cp->cc_lockp, (callb_timeout_sec * hz),
 299                             TR_CLOCK_TICK)) == -1)
 300                                 break;
 301 #endif
 302                 break;
 303
 304         case CB_CODE_CPR_RESUME:
 305                 cp->cc_events &= ~CALLB_CPR_START;
 306                 cv_signal(&cp->cc_stop_cv);
 307                 break;
 308         }
 309         mutex_exit(cp->cc_lockp);
 310         return (ret != -1);
 311 }
 312
 313 /*
 314  * The generic callback function associated with kernel threads which
 315  * are always considered safe.
 316  */
 317 /* ARGSUSED */
 318 boolean_t
 319 callb_generic_cpr_safe(void *arg, int code)
 320 {
 321         return (B_TRUE);
 322 }
 323 /*
 324  * Prevent additions to callback table.
 325  */
 326 void
 327 callb_lock_table(void)
 328 {
 329         mutex_enter(&ct->ct_lock);
 330         ASSERT(ct->ct_busy == 0);
 331         ct->ct_busy = 1;
 332         mutex_exit(&ct->ct_lock);
 333 }
 334
 335 /*
 336  * Allow additions to callback table.
 337  */
 338 void
 339 callb_unlock_table(void)
 340 {
 341         mutex_enter(&ct->ct_lock);
 342         ASSERT(ct->ct_busy != 0);
 343         ct->ct_busy = 0;
 344         cv_broadcast(&ct->ct_busy_cv);
 345         mutex_exit(&ct->ct_lock);
 346 }
 347
 348 /*
 349  * Return a boolean value indicating whether a particular kernel thread is
 350  * stopped in accordance with the cpr callback protocol.  If returning
 351  * false, also return a pointer to the thread name via the 2nd argument.
 352  */
 353 boolean_t
 354 callb_is_stopped(kthread_id_t tp, caddr_t *thread_name)
 355 {
 356         callb_t *cp;
 357         boolean_t ret_val;
 358
 359         mutex_enter(&ct->ct_lock);
 360
 361         for (cp = ct->ct_first_cb[CB_CL_CPR_DAEMON];
 362             cp != NULL && tp != cp->c_thread; cp = cp->c_next)
 363                 ;
 364
 365         ret_val = (cp != NULL);
 366         if (ret_val) {
 367                 /*
 368                  * We found the thread in the callback table and have
 369                  * provisionally set the return value to true.  Now
 370                  * see if it is marked "safe" and is sleeping or stopped.
 371                  */
 372                 callb_cpr_t *ccp = (callb_cpr_t *)cp->c_arg;
 373
 374                 *thread_name = cp->c_name;      /* in case not stopped */
 375                 mutex_enter(ccp->cc_lockp);
 376
 377                 if (ccp->cc_events & CALLB_CPR_SAFE) {
 378                         int retry;
 379
 380                         mutex_exit(ccp->cc_lockp);
 381                         for (retry = 0; retry < CALLB_MAX_RETRY; retry++) {
 382                                 thread_lock(tp);
 383                                 if (tp->t_state & (TS_SLEEP | TS_STOPPED)) {
 384                                         thread_unlock(tp);
 385                                         break;
 386                                 }
 387                                 thread_unlock(tp);
 388                                 delay(CALLB_THREAD_DELAY);
 389                         }
 390                         ret_val = retry < CALLB_MAX_RETRY;
 391                 } else {
 392                         ret_val =
 393                             (ccp->cc_events & CALLB_CPR_ALWAYS_SAFE) != 0;
 394                         mutex_exit(ccp->cc_lockp);
 395                 }
 396         } else {
 397                 /*
 398                  * Thread not found in callback table.  Make the best
 399                  * attempt to identify the thread in the error message.
 400                  */
 401                 ulong_t offset;
 402                 char *sym = kobj_getsymname((uintptr_t)tp->t_startpc,
 403                     &offset);
 404
 405                 *thread_name = sym ? sym : "*unknown*";
 406         }
 407
 408         mutex_exit(&ct->ct_lock);
 409         return (ret_val);
 410 }