zfs/lib/libzpool/zfs_fm.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   "@(#)zfs_fm.c   1.6     08/04/01 SMI"
  27
  28 #include <sys/spa.h>
  29 #include <sys/spa_impl.h>
  30 #include <sys/vdev.h>
  31 #include <sys/vdev_impl.h>
  32 #include <sys/zio.h>
  33
  34 #include <sys/fm/fs/zfs.h>
  35 #include <sys/fm/protocol.h>
  36 #include <sys/fm/util.h>
  37 #include <sys/sysevent.h>
  38
  39 /*
  40  * This general routine is responsible for generating all the different ZFS
  41  * ereports.  The payload is dependent on the class, and which arguments are
  42  * supplied to the function:
  43  *
  44  *      EREPORT                 POOL    VDEV    IO
  45  *      block                   X       X       X
  46  *      data                    X               X
  47  *      device                  X       X
  48  *      pool                    X
  49  *
  50  * If we are in a loading state, all errors are chained together by the same
  51  * SPA-wide ENA.
  52  *
  53  * For isolated I/O requests, we get the ENA from the zio_t. The propagation
  54  * gets very complicated due to RAID-Z, gang blocks, and vdev caching.  We want
  55  * to chain together all ereports associated with a logical piece of data.  For
  56  * read I/Os, there  are basically three 'types' of I/O, which form a roughly
  57  * layered diagram:
  58  *
  59  *      +---------------+
  60  *      | Aggregate I/O |       No associated logical data or device
  61  *      +---------------+
  62  *              |
  63  *              V
  64  *      +---------------+       Reads associated with a piece of logical data.
  65  *      |   Read I/O    |       This includes reads on behalf of RAID-Z,
  66  *      +---------------+       mirrors, gang blocks, retries, etc.
  67  *              |
  68  *              V
  69  *      +---------------+       Reads associated with a particular device, but
  70  *      | Physical I/O  |       no logical data.  Issued as part of vdev caching
  71  *      +---------------+       and I/O aggregation.
  72  *
  73  * Note that 'physical I/O' here is not the same terminology as used in the rest
  74  * of ZIO.  Typically, 'physical I/O' simply means that there is no attached
  75  * blockpointer.  But I/O with no associated block pointer can still be related
  76  * to a logical piece of data (i.e. RAID-Z requests).
  77  *
  78  * Purely physical I/O always have unique ENAs.  They are not related to a
  79  * particular piece of logical data, and therefore cannot be chained together.
  80  * We still generate an ereport, but the DE doesn't correlate it with any
  81  * logical piece of data.  When such an I/O fails, the delegated I/O requests
  82  * will issue a retry, which will trigger the 'real' ereport with the correct
  83  * ENA.
  84  *
  85  * We keep track of the ENA for a ZIO chain through the 'io_logical' member.
  86  * When a new logical I/O is issued, we set this to point to itself.  Child I/Os
  87  * then inherit this pointer, so that when it is first set subsequent failures
  88  * will use the same ENA.  If a physical I/O is issued (by passing the
  89  * ZIO_FLAG_NOBOOKMARK flag), then this pointer is reset, guaranteeing that a
  90  * unique ENA will be generated.  For an aggregate I/O, this pointer is set to
  91  * NULL, and no ereport will be generated (since it doesn't actually correspond
  92  * to any particular device or piece of data).
  93  */
  94 void
  95 zfs_ereport_post(const char *subclass, spa_t *spa, vdev_t *vd, zio_t *zio,
  96     uint64_t stateoroffset, uint64_t size)
  97 {
  98 #ifdef _KERNEL
  99         nvlist_t *ereport, *detector;
 100         uint64_t ena;
 101         char class[64];
 102
 103         /*
 104          * If we are doing a spa_tryimport(), ignore errors.
 105          */
 106         if (spa->spa_load_state == SPA_LOAD_TRYIMPORT)
 107                 return;
 108
 109         /*
 110          * If we are in the middle of opening a pool, and the previous attempt
 111          * failed, don't bother logging any new ereports - we're just going to
 112          * get the same diagnosis anyway.
 113          */
 114         if (spa->spa_load_state != SPA_LOAD_NONE &&
 115             spa->spa_last_open_failed)
 116                 return;
 117
 118         /*
 119          * Ignore any errors from I/Os that we are going to retry anyway - we
 120          * only generate errors from the final failure.  Checksum errors are
 121          * generated after the pipeline stage responsible for retrying the I/O
 122          * (VDEV_IO_ASSESS), so this only applies to standard I/O errors.
 123          */
 124         if (zio && zio_should_retry(zio) && zio->io_error != ECKSUM)
 125                 return;
 126
 127         /*
 128          * If this is not a read or write zio, ignore the error.  This can occur
 129          * if the DKIOCFLUSHWRITECACHE ioctl fails.
 130          */
 131         if (zio && zio->io_type != ZIO_TYPE_READ &&
 132             zio->io_type != ZIO_TYPE_WRITE)
 133                 return;
 134
 135         if ((ereport = fm_nvlist_create(NULL)) == NULL)
 136                 return;
 137
 138         if ((detector = fm_nvlist_create(NULL)) == NULL) {
 139                 fm_nvlist_destroy(ereport, FM_NVA_FREE);
 140                 return;
 141         }
 142
 143         /*
 144          * Serialize ereport generation
 145          */
 146         mutex_enter(&spa->spa_errlist_lock);
 147
 148         /*
 149          * Determine the ENA to use for this event.  If we are in a loading
 150          * state, use a SPA-wide ENA.  Otherwise, if we are in an I/O state, use
 151          * a root zio-wide ENA.  Otherwise, simply use a unique ENA.
 152          */
 153         if (spa->spa_load_state != SPA_LOAD_NONE) {
 154                 if (spa->spa_ena == 0)
 155                         spa->spa_ena = fm_ena_generate(0, FM_ENA_FMT1);
 156                 ena = spa->spa_ena;
 157         } else if (zio != NULL && zio->io_logical != NULL) {
 158                 if (zio->io_logical->io_ena == 0)
 159                         zio->io_logical->io_ena =
 160                             fm_ena_generate(0, FM_ENA_FMT1);
 161                 ena = zio->io_logical->io_ena;
 162         } else {
 163                 ena = fm_ena_generate(0, FM_ENA_FMT1);
 164         }
 165
 166         /*
 167          * Construct the full class, detector, and other standard FMA fields.
 168          */
 169         (void) snprintf(class, sizeof (class), "%s.%s",
 170             ZFS_ERROR_CLASS, subclass);
 171
 172         fm_fmri_zfs_set(detector, FM_ZFS_SCHEME_VERSION, spa_guid(spa),
 173             vd != NULL ? vd->vdev_guid : 0);
 174
 175         fm_ereport_set(ereport, FM_EREPORT_VERSION, class, ena, detector, NULL);
 176
 177         /*
 178          * Construct the per-ereport payload, depending on which parameters are
 179          * passed in.
 180          */
 181
 182         /*
 183          * Generic payload members common to all ereports.
 184          *
 185          * The direct reference to spa_name is used rather than spa_name()
 186          * because of the asynchronous nature of the zio pipeline.  spa_name()
 187          * asserts that the config lock is held in some form.  This is always
 188          * the case in I/O context, but because the check for RW_WRITER compares
 189          * against 'curthread', we may be in an asynchronous context and blow
 190          * this assert.  Rather than loosen this assert, we acknowledge that all
 191          * contexts in which this function is called (pool open, I/O) are safe,
 192          * and dereference the name directly.
 193          */
 194         fm_payload_set(ereport, FM_EREPORT_PAYLOAD_ZFS_POOL,
 195             DATA_TYPE_STRING, spa->spa_name, FM_EREPORT_PAYLOAD_ZFS_POOL_GUID,
 196             DATA_TYPE_UINT64, spa_guid(spa),
 197             FM_EREPORT_PAYLOAD_ZFS_POOL_CONTEXT, DATA_TYPE_INT32,
 198             spa->spa_load_state, NULL);
 199
 200         if (vd != NULL) {
 201                 vdev_t *pvd = vd->vdev_parent;
 202
 203                 fm_payload_set(ereport, FM_EREPORT_PAYLOAD_ZFS_VDEV_GUID,
 204                     DATA_TYPE_UINT64, vd->vdev_guid,
 205                     FM_EREPORT_PAYLOAD_ZFS_VDEV_TYPE,
 206                     DATA_TYPE_STRING, vd->vdev_ops->vdev_op_type, NULL);
 207                 if (vd->vdev_path)
 208                         fm_payload_set(ereport,
 209                             FM_EREPORT_PAYLOAD_ZFS_VDEV_PATH,
 210                             DATA_TYPE_STRING, vd->vdev_path, NULL);
 211                 if (vd->vdev_devid)
 212                         fm_payload_set(ereport,
 213                             FM_EREPORT_PAYLOAD_ZFS_VDEV_DEVID,
 214                             DATA_TYPE_STRING, vd->vdev_devid, NULL);
 215
 216                 if (pvd != NULL) {
 217                         fm_payload_set(ereport,
 218                             FM_EREPORT_PAYLOAD_ZFS_PARENT_GUID,
 219                             DATA_TYPE_UINT64, pvd->vdev_guid,
 220                             FM_EREPORT_PAYLOAD_ZFS_PARENT_TYPE,
 221                             DATA_TYPE_STRING, pvd->vdev_ops->vdev_op_type,
 222                             NULL);
 223                         if (pvd->vdev_path)
 224                                 fm_payload_set(ereport,
 225                                     FM_EREPORT_PAYLOAD_ZFS_PARENT_PATH,
 226                                     DATA_TYPE_STRING, pvd->vdev_path, NULL);
 227                         if (pvd->vdev_devid)
 228                                 fm_payload_set(ereport,
 229                                     FM_EREPORT_PAYLOAD_ZFS_PARENT_DEVID,
 230                                     DATA_TYPE_STRING, pvd->vdev_devid, NULL);
 231                 }
 232         }
 233
 234         if (zio != NULL) {
 235                 /*
 236                  * Payload common to all I/Os.
 237                  */
 238                 fm_payload_set(ereport, FM_EREPORT_PAYLOAD_ZFS_ZIO_ERR,
 239                     DATA_TYPE_INT32, zio->io_error, NULL);
 240
 241                 /*
 242                  * If the 'size' parameter is non-zero, it indicates this is a
 243                  * RAID-Z or other I/O where the physical offset and length are
 244                  * provided for us, instead of within the zio_t.
 245                  */
 246                 if (vd != NULL) {
 247                         if (size)
 248                                 fm_payload_set(ereport,
 249                                     FM_EREPORT_PAYLOAD_ZFS_ZIO_OFFSET,
 250                                     DATA_TYPE_UINT64, stateoroffset,
 251                                     FM_EREPORT_PAYLOAD_ZFS_ZIO_SIZE,
 252                                     DATA_TYPE_UINT64, size, NULL);
 253                         else
 254                                 fm_payload_set(ereport,
 255                                     FM_EREPORT_PAYLOAD_ZFS_ZIO_OFFSET,
 256                                     DATA_TYPE_UINT64, zio->io_offset,
 257                                     FM_EREPORT_PAYLOAD_ZFS_ZIO_SIZE,
 258                                     DATA_TYPE_UINT64, zio->io_size, NULL);
 259                 }
 260
 261                 /*
 262                  * Payload for I/Os with corresponding logical information.
 263                  */
 264                 if (zio->io_logical != NULL)
 265                         fm_payload_set(ereport,
 266                             FM_EREPORT_PAYLOAD_ZFS_ZIO_OBJSET,
 267                             DATA_TYPE_UINT64,
 268                             zio->io_logical->io_bookmark.zb_objset,
 269                             FM_EREPORT_PAYLOAD_ZFS_ZIO_OBJECT,
 270                             DATA_TYPE_UINT64,
 271                             zio->io_logical->io_bookmark.zb_object,
 272                             FM_EREPORT_PAYLOAD_ZFS_ZIO_LEVEL,
 273                             DATA_TYPE_INT64,
 274                             zio->io_logical->io_bookmark.zb_level,
 275                             FM_EREPORT_PAYLOAD_ZFS_ZIO_BLKID,
 276                             DATA_TYPE_UINT64,
 277                             zio->io_logical->io_bookmark.zb_blkid, NULL);
 278         } else if (vd != NULL) {
 279                 /*
 280                  * If we have a vdev but no zio, this is a device fault, and the
 281                  * 'stateoroffset' parameter indicates the previous state of the
 282                  * vdev.
 283                  */
 284                 fm_payload_set(ereport,
 285                     FM_EREPORT_PAYLOAD_ZFS_PREV_STATE,
 286                     DATA_TYPE_UINT64, stateoroffset, NULL);
 287         }
 288         mutex_exit(&spa->spa_errlist_lock);
 289
 290         fm_ereport_post(ereport, EVCH_SLEEP);
 291
 292         fm_nvlist_destroy(ereport, FM_NVA_FREE);
 293         fm_nvlist_destroy(detector, FM_NVA_FREE);
 294 #endif
 295 }
 296
 297 static void
 298 zfs_post_common(spa_t *spa, vdev_t *vd, const char *name)
 299 {
 300 #ifdef _KERNEL
 301         nvlist_t *resource;
 302         char class[64];
 303
 304         if ((resource = fm_nvlist_create(NULL)) == NULL)
 305                 return;
 306
 307         (void) snprintf(class, sizeof (class), "%s.%s.%s", FM_RSRC_RESOURCE,
 308             ZFS_ERROR_CLASS, name);
 309         VERIFY(nvlist_add_uint8(resource, FM_VERSION, FM_RSRC_VERSION) == 0);
 310         VERIFY(nvlist_add_string(resource, FM_CLASS, class) == 0);
 311         VERIFY(nvlist_add_uint64(resource,
 312             FM_EREPORT_PAYLOAD_ZFS_POOL_GUID, spa_guid(spa)) == 0);
 313         if (vd)
 314                 VERIFY(nvlist_add_uint64(resource,
 315                     FM_EREPORT_PAYLOAD_ZFS_VDEV_GUID, vd->vdev_guid) == 0);
 316
 317         fm_ereport_post(resource, EVCH_SLEEP);
 318
 319         fm_nvlist_destroy(resource, FM_NVA_FREE);
 320 #endif
 321 }
 322
 323 /*
 324  * The 'resource.fs.zfs.ok' event is an internal signal that the associated
 325  * resource (pool or disk) has been identified by ZFS as healthy.  This will
 326  * then trigger the DE to close the associated case, if any.
 327  */
 328 void
 329 zfs_post_ok(spa_t *spa, vdev_t *vd)
 330 {
 331         zfs_post_common(spa, vd, FM_RESOURCE_OK);
 332 }
 333
 334 /*
 335  * The 'resource.fs.zfs.removed' event is an internal signal that the given vdev
 336  * has been removed from the system.  This will cause the DE to ignore any
 337  * recent I/O errors, inferring that they are due to the asynchronous device
 338  * removal.
 339  */
 340 void
 341 zfs_post_remove(spa_t *spa, vdev_t *vd)
 342 {
 343         zfs_post_common(spa, vd, FM_RESOURCE_REMOVED);
 344 }
 345
 346 /*
 347  * The 'resource.fs.zfs.autoreplace' event is an internal signal that the pool
 348  * has the 'autoreplace' property set, and therefore any broken vdevs will be
 349  * handled by higher level logic, and no vdev fault should be generated.
 350  */
 351 void
 352 zfs_post_autoreplace(spa_t *spa, vdev_t *vd)
 353 {
 354         zfs_post_common(spa, vd, FM_RESOURCE_AUTOREPLACE);
 355 }