kernel/cpr/cpr_driver.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 2007 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 /*
  29  * CPR driver support routines
  30  */
  31
  32 #include <sys/types.h>
  33 #include <sys/errno.h>
  34 #include <sys/kmem.h>
  35 #include <sys/systm.h>
  36 #include <sys/sunddi.h>
  37 #include <sys/ddi_impldefs.h>
  38 #include <sys/epm.h>
  39 #include <sys/cpr.h>
  40
  41 #define CPR_BUFSIZE     128
  42
  43 extern int devi_detach(dev_info_t *, int);
  44 extern int devi_attach(dev_info_t *, int);
  45
  46 static char     *devi_string(dev_info_t *, char *);
  47 static int      cpr_is_real_device(dev_info_t *);
  48 /*
  49  * Xen uses this code to suspend _all_ drivers quickly and easily.
  50  * Suspend and Resume uses it for the same reason, but also has
  51  * to contend with some platform specific code that Xen does not.
  52  * it is also used as a test entry point for developers/testers to
  53  * execute code without going through a complete suspend.  So additions
  54  * that have platform implications shall need #if[n]def's.
  55  */
  56 extern void     i_cpr_save_configuration(dev_info_t *);
  57 extern void     i_cpr_restore_configuration(dev_info_t *);
  58
  59 /*
  60  * Traverse the dev info tree:
  61  *      Call each device driver in the system via a special case
  62  *      of the detach() entry point to quiesce itself.
  63  *      Suspend children first.
  64  *
  65  * We only suspend/resume real devices.
  66  */
  67
  68 int
  69 cpr_suspend_devices(dev_info_t *dip)
  70 {
  71         int             error;
  72         char            buf[CPR_BUFSIZE];
  73
  74         for (; dip != NULL; dip = ddi_get_next_sibling(dip)) {
  75                 if (cpr_suspend_devices(ddi_get_child(dip)))
  76                         return (ENXIO);
  77                 if (!cpr_is_real_device(dip))
  78                         continue;
  79                 CPR_DEBUG(CPR_DEBUG2, "Suspending device %s\n",
  80                     devi_string(dip, buf));
  81                 ASSERT((DEVI(dip)->devi_cpr_flags & DCF_CPR_SUSPENDED) == 0);
  82
  83                 i_cpr_save_configuration(dip);
  84
  85
  86                 if (!i_ddi_devi_attached(dip)) {
  87                         error = DDI_FAILURE;
  88                 } else {
  89                         if (cpr_test_point != DEVICE_SUSPEND_TO_RAM ||
  90                             (cpr_test_point == DEVICE_SUSPEND_TO_RAM &&
  91                             cpr_device == ddi_driver_major(dip))) {
  92                                 error = devi_detach(dip, DDI_SUSPEND);
  93                         } else {
  94                                 error = DDI_SUCCESS;
  95                         }
  96                 }
  97
  98                 if (error == DDI_SUCCESS) {
  99                         DEVI(dip)->devi_cpr_flags |= DCF_CPR_SUSPENDED;
 100                 }
 101
 102                 else {
 103                         CPR_DEBUG(CPR_DEBUG2,
 104                             "WARNING: Unable to suspend device %s\n",
 105                             devi_string(dip, buf));
 106                         cpr_err(CE_WARN, "Unable to suspend device %s.",
 107                             devi_string(dip, buf));
 108                         cpr_err(CE_WARN, "Device is busy or does not "
 109                             "support suspend/resume.");
 110                         /*
 111                          * the device has failed to suspend however,
 112                          * if cpr_test_point == FORCE_SUSPEND_TO_RAM
 113                          * after putting out the warning message above,
 114                          * we carry on as if suspending the device had
 115                          * been successful
 116                          */
 117                         if (cpr_test_point == FORCE_SUSPEND_TO_RAM)
 118                                 DEVI(dip)->devi_cpr_flags |= DCF_CPR_SUSPENDED;
 119                         else
 120                                 return (ENXIO);
 121                 }
 122         }
 123         return (0);
 124 }
 125
 126 /*
 127  * Traverse the dev info tree:
 128  *      Call each device driver in the system via a special case
 129  *      of the attach() entry point to restore itself.
 130  *      This is a little tricky because it has to reverse the traversal
 131  *      order of cpr_suspend_devices().
 132  */
 133 int
 134 cpr_resume_devices(dev_info_t *start, int resume_failed)
 135 {
 136         dev_info_t      *dip, *next, *last = NULL;
 137         int             did_suspend;
 138         int             error = resume_failed;
 139         char            buf[CPR_BUFSIZE];
 140
 141         while (last != start) {
 142                 dip = start;
 143                 next = ddi_get_next_sibling(dip);
 144                 while (next != last) {
 145                         dip = next;
 146                         next = ddi_get_next_sibling(dip);
 147                 }
 148
 149                 /*
 150                  * cpr is the only one that uses this field and the device
 151                  * itself hasn't resumed yet, there is no need to use a
 152                  * lock, even though kernel threads are active by now.
 153                  */
 154                 did_suspend = DEVI(dip)->devi_cpr_flags & DCF_CPR_SUSPENDED;
 155                 if (did_suspend)
 156                         DEVI(dip)->devi_cpr_flags &= ~DCF_CPR_SUSPENDED;
 157
 158                 /*
 159                  * Always attempt to restore device configuration before
 160                  * attempting resume
 161                  */
 162                 i_cpr_restore_configuration(dip);
 163
 164                 /*
 165                  * There may be background attaches happening on devices
 166                  * that were not originally suspended by cpr, so resume
 167                  * only devices that were suspended by cpr. Also, stop
 168                  * resuming after the first resume failure, but traverse
 169                  * the entire tree to clear the suspend flag unless the
 170                  * FORCE_SUSPEND_TO_RAM test point is set.
 171                  */
 172                 if (did_suspend && (!error ||
 173                     cpr_test_point == FORCE_SUSPEND_TO_RAM)) {
 174                         CPR_DEBUG(CPR_DEBUG2, "Resuming device %s\n",
 175                             devi_string(dip, buf));
 176                         /*
 177                          * If a device suspended by cpr gets detached during
 178                          * the resume process (for example, due to hotplugging)
 179                          * before cpr gets around to issuing it a DDI_RESUME,
 180                          * we'll have problems.
 181                          */
 182                         if (!i_ddi_devi_attached(dip)) {
 183                                 CPR_DEBUG(CPR_DEBUG2, "WARNING: Skipping "
 184                                     "%s, device not ready for resume\n",
 185                                     devi_string(dip, buf));
 186                                 cpr_err(CE_WARN, "Skipping %s, device "
 187                                     "not ready for resume",
 188                                     devi_string(dip, buf));
 189                         } else if (cpr_test_point != DEVICE_SUSPEND_TO_RAM ||
 190                             (cpr_test_point == DEVICE_SUSPEND_TO_RAM &&
 191                             cpr_device == ddi_driver_major(dip))) {
 192                                 if (devi_attach(dip, DDI_RESUME) !=
 193                                     DDI_SUCCESS) {
 194                                         error = ENXIO;
 195                                 }
 196                         }
 197                 }
 198
 199                 if (error == ENXIO) {
 200                         CPR_DEBUG(CPR_DEBUG2,
 201                             "WARNING: Unable to resume device %s\n",
 202                             devi_string(dip, buf));
 203                         cpr_err(CE_WARN, "Unable to resume device %s",
 204                             devi_string(dip, buf));
 205                 }
 206
 207                 error = cpr_resume_devices(ddi_get_child(dip), error);
 208                 last = dip;
 209         }
 210
 211         return (error);
 212 }
 213
 214 /*
 215  * Returns a string which contains device name and address.
 216  */
 217 static char *
 218 devi_string(dev_info_t *devi, char *buf)
 219 {
 220         char *name;
 221         char *address;
 222         int size;
 223
 224         name = ddi_node_name(devi);
 225         address = ddi_get_name_addr(devi);
 226         size = (name == NULL) ? strlen("<null name>") : strlen(name);
 227         size += (address == NULL) ? strlen("<null>") : strlen(address);
 228
 229         /*
 230          * Make sure that we don't over-run the buffer.
 231          * There are 2 additional characters in the string.
 232          */
 233         ASSERT((size + 2) <= CPR_BUFSIZE);
 234
 235         if (name == NULL)
 236                 (void) strcpy(buf, "<null name>");
 237         else
 238                 (void) strcpy(buf, name);
 239
 240         (void) strcat(buf, "@");
 241         if (address == NULL)
 242                 (void) strcat(buf, "<null>");
 243         else
 244                 (void) strcat(buf, address);
 245
 246         return (buf);
 247 }
 248
 249 /*
 250  * This function determines whether the given device is real (and should
 251  * be suspended) or not (pseudo like).  If the device has a "reg" property
 252  * then it is presumed to have register state to save/restore.
 253  */
 254 static int
 255 cpr_is_real_device(dev_info_t *dip)
 256 {
 257         struct regspec *regbuf;
 258         int length;
 259         int rc;
 260
 261         if (ddi_get_driver(dip) == NULL)
 262                 return (0);
 263
 264         /*
 265          * First those devices for which special arrangements have been made
 266          */
 267         if (DEVI(dip)->devi_pm_flags & (PMC_NEEDS_SR|PMC_PARENTAL_SR))
 268                 return (1);
 269         if (DEVI(dip)->devi_pm_flags & PMC_NO_SR)
 270                 return (0);
 271
 272         /*
 273          * now the general case
 274          */
 275         rc = ddi_getlongprop(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "reg",
 276             (caddr_t)&regbuf, &length);
 277         ASSERT(rc != DDI_PROP_NO_MEMORY);
 278         if (rc != DDI_PROP_SUCCESS) {
 279                 return (0);
 280         } else {
 281                 kmem_free((caddr_t)regbuf, length);
 282                 return (1);
 283         }
 284 }