usr/src/cmd/fm/modules/sun4/cpumem-diagnosis/cmd_page.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 /*
  29  * Support routines for managing per-page state.
  30  */
  31
  32 #include <cmd_page.h>
  33 #include <cmd_mem.h>
  34 #include <cmd.h>
  35 #ifdef sun4u
  36 #include <cmd_dp_page.h>
  37 #endif
  38
  39 #include <errno.h>
  40 #include <strings.h>
  41 #include <fm/fmd_api.h>
  42 #include <sys/fm/protocol.h>
  43
  44 static void
  45 page_write(fmd_hdl_t *hdl, cmd_page_t *page)
  46 {
  47         fmd_buf_write(hdl, NULL, page->page_bufname, page,
  48             sizeof (cmd_page_pers_t));
  49 }
  50
  51 static void
  52 cmd_page_free(fmd_hdl_t *hdl, cmd_page_t *page, int destroy)
  53 {
  54         cmd_case_t *cc = &page->page_case;
  55
  56         if (cc->cc_cp != NULL)
  57                 cmd_case_fini(hdl, cc->cc_cp, destroy);
  58
  59         if (cc->cc_serdnm != NULL) {
  60                 if (fmd_serd_exists(hdl, cc->cc_serdnm) && destroy)
  61                         fmd_serd_destroy(hdl, cc->cc_serdnm);
  62                 fmd_hdl_strfree(hdl, cc->cc_serdnm);
  63         }
  64
  65         if (destroy)
  66                 fmd_buf_destroy(hdl, NULL, page->page_bufname);
  67
  68         cmd_fmri_fini(hdl, &page->page_asru, destroy);
  69
  70         cmd_list_delete(&cmd.cmd_pages, page);
  71         fmd_hdl_free(hdl, page, sizeof (cmd_page_t));
  72 }
  73
  74 void
  75 cmd_page_destroy(fmd_hdl_t *hdl, cmd_page_t *page)
  76 {
  77         cmd_page_free(hdl, page, FMD_B_TRUE);
  78 }
  79
  80 static cmd_page_t *
  81 page_lookup_by_physaddr(uint64_t pa)
  82 {
  83         cmd_page_t *page;
  84
  85         for (page = cmd_list_next(&cmd.cmd_pages); page != NULL;
  86             page = cmd_list_next(page)) {
  87                 if (page->page_physbase == pa)
  88                         return (page);
  89         }
  90
  91         return (NULL);
  92 }
  93
  94 cmd_page_t *
  95 cmd_page_create(fmd_hdl_t *hdl, nvlist_t *modasru, uint64_t pa)
  96 {
  97         cmd_page_t *page;
  98         nvlist_t *asru;
  99
 100         pa = pa & cmd.cmd_pagemask;
 101
 102         fmd_hdl_debug(hdl, "page_lookup: creating new page for %llx\n",
 103             (u_longlong_t)pa);
 104         CMD_STAT_BUMP(page_creat);
 105
 106         page = fmd_hdl_zalloc(hdl, sizeof (cmd_page_t), FMD_SLEEP);
 107         page->page_nodetype = CMD_NT_PAGE;
 108         page->page_version = CMD_PAGE_VERSION;
 109         page->page_physbase = pa;
 110
 111         cmd_bufname(page->page_bufname, sizeof (page->page_bufname),
 112             "page_%llx", (u_longlong_t)pa);
 113
 114         if ((errno = nvlist_dup(modasru, &asru, 0)) != 0 ||
 115             (errno = nvlist_add_uint64(asru, FM_FMRI_MEM_PHYSADDR,
 116             page->page_physbase)) != 0 ||
 117             (errno = fmd_nvl_fmri_expand(hdl, asru)) != 0)
 118                 fmd_hdl_abort(hdl, "failed to build page fmri");
 119
 120         cmd_fmri_init(hdl, &page->page_asru, asru, "page_asru_%llx",
 121             (u_longlong_t)pa);
 122
 123         nvlist_free(asru);
 124
 125         cmd_list_append(&cmd.cmd_pages, page);
 126         page_write(hdl, page);
 127
 128         return (page);
 129 }
 130
 131 cmd_page_t *
 132 cmd_page_lookup(uint64_t pa)
 133 {
 134         pa = pa & cmd.cmd_pagemask;
 135
 136         return (page_lookup_by_physaddr(pa));
 137 }
 138
 139 static cmd_page_t *
 140 page_v0tov1(fmd_hdl_t *hdl, cmd_page_0_t *old, size_t oldsz)
 141 {
 142         cmd_page_t *new;
 143
 144         if (oldsz != sizeof (cmd_page_0_t)) {
 145                 fmd_hdl_abort(hdl, "size of state doesn't match size of "
 146                     "version 0 state (%u bytes).\n", sizeof (cmd_page_0_t));
 147         }
 148
 149         new = fmd_hdl_zalloc(hdl, sizeof (cmd_page_t), FMD_SLEEP);
 150         new->page_header = old->page0_header;
 151         new->page_version = CMD_PAGE_VERSION;
 152         new->page_asru = old->page0_asru;
 153
 154         fmd_hdl_free(hdl, old, oldsz);
 155         return (new);
 156 }
 157
 158 static cmd_page_t *
 159 page_wrapv1(fmd_hdl_t *hdl, cmd_page_pers_t *pers, size_t psz)
 160 {
 161         cmd_page_t *page;
 162
 163         if (psz != sizeof (cmd_page_pers_t)) {
 164                 fmd_hdl_abort(hdl, "size of state doesn't match size of "
 165                     "version 1 state (%u bytes).\n", sizeof (cmd_page_pers_t));
 166         }
 167
 168         page = fmd_hdl_zalloc(hdl, sizeof (cmd_page_t), FMD_SLEEP);
 169         bcopy(pers, page, sizeof (cmd_page_pers_t));
 170         fmd_hdl_free(hdl, pers, psz);
 171         return (page);
 172 }
 173
 174 void *
 175 cmd_page_restore(fmd_hdl_t *hdl, fmd_case_t *cp, cmd_case_ptr_t *ptr)
 176 {
 177         cmd_page_t *page;
 178
 179         for (page = cmd_list_next(&cmd.cmd_pages); page != NULL;
 180             page = cmd_list_next(page)) {
 181                 if (strcmp(page->page_bufname, ptr->ptr_name) == 0)
 182                         break;
 183         }
 184
 185         if (page == NULL) {
 186                 int migrated = 0;
 187                 size_t pagesz;
 188
 189                 fmd_hdl_debug(hdl, "restoring page from %s\n", ptr->ptr_name);
 190
 191                 if ((pagesz = fmd_buf_size(hdl, NULL, ptr->ptr_name)) == 0) {
 192                         if (fmd_case_solved(hdl, cp) ||
 193                             fmd_case_closed(hdl, cp)) {
 194                                 fmd_hdl_debug(hdl, "page %s from case %s not "
 195                                     "found. Case is already solved or closed\n",
 196                                     ptr->ptr_name, fmd_case_uuid(hdl, cp));
 197                                 return (NULL);
 198                         } else {
 199                                 fmd_hdl_abort(hdl, "page referenced by case %s "
 200                                     "does not exist in saved state\n",
 201                                     fmd_case_uuid(hdl, cp));
 202                         }
 203                 } else if (pagesz > CMD_PAGE_MAXSIZE ||
 204                     pagesz < CMD_PAGE_MINSIZE) {
 205                         fmd_hdl_abort(hdl, "page buffer referenced by case %s "
 206                             "is out of bounds (is %u bytes, max %u, min %u)\n",
 207                             fmd_case_uuid(hdl, cp), pagesz,
 208                             CMD_PAGE_MAXSIZE, CMD_PAGE_MINSIZE);
 209                 }
 210
 211                 if ((page = cmd_buf_read(hdl, NULL, ptr->ptr_name,
 212                     pagesz)) == NULL) {
 213                         fmd_hdl_abort(hdl, "failed to read page buf %s",
 214                             ptr->ptr_name);
 215                 }
 216
 217                 fmd_hdl_debug(hdl, "found %d in version field\n",
 218                     page->page_version);
 219
 220                 if (CMD_PAGE_VERSIONED(page)) {
 221                         switch (page->page_version) {
 222                         case CMD_PAGE_VERSION_1:
 223                                 page = page_wrapv1(hdl, (cmd_page_pers_t *)page,
 224                                     pagesz);
 225                                 break;
 226                         default:
 227                                 fmd_hdl_abort(hdl, "unknown version (found %d) "
 228                                     "for page state referenced by case %s.\n",
 229                                     page->page_version, fmd_case_uuid(hdl, cp));
 230                                 break;
 231                         }
 232                 } else {
 233                         page = page_v0tov1(hdl, (cmd_page_0_t *)page, pagesz);
 234                         migrated = 1;
 235                 }
 236
 237                 if (migrated) {
 238 /*                      CMD_STAT_BUMP(page_migrat);     */
 239                         cmd_page_dirty(hdl, page);
 240                 }
 241
 242                 cmd_fmri_restore(hdl, &page->page_asru);
 243
 244                 cmd_list_append(&cmd.cmd_pages, page);
 245         }
 246
 247         switch (ptr->ptr_subtype) {
 248         case BUG_PTR_PAGE_CASE:
 249                 fmd_hdl_debug(hdl, "recovering from out of order page ptr\n");
 250                 cmd_case_redirect(hdl, cp, CMD_PTR_PAGE_CASE);
 251                 /*FALLTHROUGH*/
 252         case CMD_PTR_PAGE_CASE:
 253                 cmd_case_restore(hdl, &page->page_case, cp,
 254                     cmd_page_serdnm_create(hdl, "page", page->page_physbase));
 255                 break;
 256
 257 #ifdef sun4u
 258         case CMD_PTR_DP_PAGE_DEFER:
 259                 page->page_case.cc_cp = cp;
 260                 cmd_dp_page_restore(hdl, page);
 261                 break;
 262 #endif
 263         default:
 264                 fmd_hdl_abort(hdl, "invalid %s subtype %d\n",
 265                     ptr->ptr_name, ptr->ptr_subtype);
 266         }
 267
 268         return (page);
 269 }
 270
 271
 272 /*ARGSUSED*/
 273 void
 274 cmd_page_validate(fmd_hdl_t *hdl)
 275 {
 276         cmd_page_t *page, *next;
 277
 278         for (page = cmd_list_next(&cmd.cmd_pages); page != NULL; page = next) {
 279                 next = cmd_list_next(page);
 280
 281                 if (fmd_nvl_fmri_unusable(hdl, page->page_asru_nvl)) {
 282 #ifdef sun4u
 283                         if (cmd_dp_page_isdeferred(hdl, page) &&
 284                             fmd_nvl_fmri_present(hdl, page->page_asru_nvl))
 285                                         continue;
 286 #endif
 287                         cmd_page_destroy(hdl, page);
 288                 }
 289         }
 290 }
 291
 292 void
 293 cmd_page_dirty(fmd_hdl_t *hdl, cmd_page_t *page)
 294 {
 295         if (fmd_buf_size(hdl, NULL, page->page_bufname) !=
 296             sizeof (cmd_page_pers_t))
 297                 fmd_buf_destroy(hdl, NULL, page->page_bufname);
 298
 299         /* No need to rewrite the FMRIs in the page - they don't change */
 300         fmd_buf_write(hdl, NULL, page->page_bufname, &page->page_pers,
 301             sizeof (cmd_page_pers_t));
 302 }
 303
 304 void
 305 cmd_page_fini(fmd_hdl_t *hdl)
 306 {
 307         cmd_page_t *page;
 308
 309         while ((page = cmd_list_next(&cmd.cmd_pages)) != NULL)
 310                 cmd_page_free(hdl, page, FMD_B_FALSE);
 311 }