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 (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 25 #include <strings.h> 26 #include <fm/fmd_fmri.h> 27 #include <fm/libtopo.h> 28 #include <fm/topo_mod.h> 29 30 int 31 fmd_fmri_init(void) 32 { 33 return (0); 34 } 35 36 void 37 fmd_fmri_fini(void) 38 { 39 } 40 41 ssize_t 42 fmd_fmri_nvl2str(nvlist_t *nvl, char *buf, size_t buflen) 43 { 44 int err; 45 uint8_t version; 46 ssize_t len; 47 topo_hdl_t *thp; 48 char *str; 49 50 if (nvlist_lookup_uint8(nvl, FM_VERSION, &version) != 0 || 51 version > FM_HC_SCHEME_VERSION) 52 return (fmd_fmri_set_errno(EINVAL)); 53 54 if ((thp = fmd_fmri_topo_hold(TOPO_VERSION)) == NULL) 55 return (fmd_fmri_set_errno(EINVAL)); 56 if (topo_fmri_nvl2str(thp, nvl, &str, &err) != 0) { 57 fmd_fmri_topo_rele(thp); 58 return (fmd_fmri_set_errno(EINVAL)); 59 } 60 61 if (buf != NULL) 62 len = snprintf(buf, buflen, "%s", str); 63 else 64 len = strlen(str); 65 66 topo_hdl_strfree(thp, str); 67 fmd_fmri_topo_rele(thp); 68 69 return (len); 70 } 71 72 int 73 fmd_fmri_present(nvlist_t *nvl) 74 { 75 int err, present; 76 topo_hdl_t *thp; 77 nvlist_t **hcprs; 78 char *nm; 79 uint_t hcnprs; 80 81 err = nvlist_lookup_nvlist_array(nvl, FM_FMRI_HC_LIST, &hcprs, &hcnprs); 82 if (err != 0) 83 return (fmd_fmri_set_errno(EINVAL)); 84 err = nvlist_lookup_string(hcprs[0], FM_FMRI_HC_NAME, &nm); 85 if (err != 0) 86 return (fmd_fmri_set_errno(EINVAL)); 87 88 if ((thp = fmd_fmri_topo_hold(TOPO_VERSION)) == NULL) 89 return (fmd_fmri_set_errno(EINVAL)); 90 present = topo_fmri_present(thp, nvl, &err); 91 fmd_fmri_topo_rele(thp); 92 93 return (present); 94 } 95 96 int 97 fmd_fmri_replaced(nvlist_t *nvl) 98 { 99 int err, replaced; 100 topo_hdl_t *thp; 101 nvlist_t **hcprs; 102 char *nm; 103 uint_t hcnprs; 104 105 err = nvlist_lookup_nvlist_array(nvl, FM_FMRI_HC_LIST, &hcprs, &hcnprs); 106 if (err != 0) 107 return (fmd_fmri_set_errno(EINVAL)); 108 err = nvlist_lookup_string(hcprs[0], FM_FMRI_HC_NAME, &nm); 109 if (err != 0) 110 return (fmd_fmri_set_errno(EINVAL)); 111 112 if ((thp = fmd_fmri_topo_hold(TOPO_VERSION)) == NULL) 113 return (fmd_fmri_set_errno(EINVAL)); 114 replaced = topo_fmri_replaced(thp, nvl, &err); 115 fmd_fmri_topo_rele(thp); 116 117 return (replaced); 118 } 119 120 int 121 fmd_fmri_unusable(nvlist_t *nvl) 122 { 123 int err, unusable; 124 topo_hdl_t *thp; 125 nvlist_t **hcprs; 126 char *nm; 127 uint_t hcnprs; 128 129 if (nvlist_lookup_nvlist_array(nvl, FM_FMRI_HC_LIST, 130 &hcprs, &hcnprs) != 0 || 131 nvlist_lookup_string(hcprs[0], FM_FMRI_HC_NAME, &nm) != 0) 132 return (0); 133 134 if ((thp = fmd_fmri_topo_hold(TOPO_VERSION)) == NULL) 135 return (fmd_fmri_set_errno(EINVAL)); 136 unusable = topo_fmri_unusable(thp, nvl, &err); 137 fmd_fmri_topo_rele(thp); 138 139 return (unusable == 1 ? 1 : 0); 140 } 141 142 static int 143 auth_compare(nvlist_t *nvl1, nvlist_t *nvl2) 144 { 145 const char *names[] = { 146 FM_FMRI_AUTH_PRODUCT, 147 FM_FMRI_AUTH_PRODUCT_SN, 148 FM_FMRI_AUTH_CHASSIS, 149 FM_FMRI_AUTH_SERVER, 150 FM_FMRI_AUTH_DOMAIN, 151 FM_FMRI_AUTH_HOST, 152 NULL 153 }; 154 const char **namep; 155 nvlist_t *auth1 = NULL, *auth2 = NULL; 156 157 (void) nvlist_lookup_nvlist(nvl1, FM_FMRI_AUTHORITY, &auth1); 158 (void) nvlist_lookup_nvlist(nvl2, FM_FMRI_AUTHORITY, &auth2); 159 if (auth1 == NULL && auth2 == NULL) 160 return (0); 161 if (auth1 == NULL || auth2 == NULL) 162 return (1); 163 164 for (namep = names; *namep != NULL; namep++) { 165 char *val1 = NULL, *val2 = NULL; 166 167 (void) nvlist_lookup_string(auth1, *namep, &val1); 168 (void) nvlist_lookup_string(auth2, *namep, &val2); 169 if (val1 == NULL && val2 == NULL) 170 continue; 171 if (val1 == NULL || val2 == NULL || strcmp(val1, val2) != 0) 172 return (1); 173 } 174 175 return (0); 176 } 177 178 static int 179 hclist_contains(nvlist_t **erhcl, uint_t erhclsz, nvlist_t **eehcl, 180 uint_t eehclsz) 181 { 182 uint_t i; 183 char *erval, *eeval; 184 185 if (erhclsz > eehclsz || erhcl == NULL || eehcl == NULL) 186 return (0); 187 188 for (i = 0; i < erhclsz; i++) { 189 (void) nvlist_lookup_string(erhcl[i], FM_FMRI_HC_NAME, 190 &erval); 191 (void) nvlist_lookup_string(eehcl[i], FM_FMRI_HC_NAME, 192 &eeval); 193 if (strcmp(erval, eeval) != 0) 194 return (0); 195 (void) nvlist_lookup_string(erhcl[i], FM_FMRI_HC_ID, 196 &erval); 197 (void) nvlist_lookup_string(eehcl[i], FM_FMRI_HC_ID, 198 &eeval); 199 if (strcmp(erval, eeval) != 0) 200 return (0); 201 } 202 203 return (1); 204 } 205 206 static int 207 fru_compare(nvlist_t *r1, nvlist_t *r2) 208 { 209 topo_hdl_t *thp; 210 nvlist_t *f1 = NULL, *f2 = NULL; 211 nvlist_t **h1 = NULL, **h2 = NULL; 212 uint_t h1sz, h2sz; 213 int err, rc = 1; 214 215 if ((thp = fmd_fmri_topo_hold(TOPO_VERSION)) == NULL) 216 return (fmd_fmri_set_errno(EINVAL)); 217 218 (void) topo_fmri_fru(thp, r1, &f1, &err); 219 (void) topo_fmri_fru(thp, r2, &f2, &err); 220 if (f1 != NULL && f2 != NULL) { 221 (void) nvlist_lookup_nvlist_array(f1, FM_FMRI_HC_LIST, &h1, 222 &h1sz); 223 (void) nvlist_lookup_nvlist_array(f2, FM_FMRI_HC_LIST, &h2, 224 &h2sz); 225 if (h1sz == h2sz && hclist_contains(h1, h1sz, h2, h2sz) == 1) 226 rc = 0; 227 } 228 229 fmd_fmri_topo_rele(thp); 230 nvlist_free(f1); 231 nvlist_free(f2); 232 return (rc); 233 } 234 235 int 236 fmd_fmri_contains(nvlist_t *er, nvlist_t *ee) 237 { 238 nvlist_t **erhcl, **eehcl; 239 uint_t erhclsz, eehclsz; 240 nvlist_t *hcsp; 241 uint64_t eroff, eeoff; 242 243 if (nvlist_lookup_nvlist_array(er, FM_FMRI_HC_LIST, &erhcl, 244 &erhclsz) != 0 || nvlist_lookup_nvlist_array(ee, 245 FM_FMRI_HC_LIST, &eehcl, &eehclsz) != 0) 246 return (fmd_fmri_set_errno(EINVAL)); 247 248 /* 249 * Check ee is further down the hc tree than er; er and ee have 250 * the same auth and are on the same fru. 251 */ 252 if (hclist_contains(erhcl, erhclsz, eehcl, eehclsz) == 0 || 253 auth_compare(er, ee) != 0 || fru_compare(er, ee) != 0) 254 return (0); 255 256 /* 257 * return true if er is parent of ee, or er is not a page 258 */ 259 if (erhclsz < eehclsz || nvlist_lookup_nvlist(er, 260 FM_FMRI_HC_SPECIFIC, &hcsp) != 0 || (nvlist_lookup_uint64(hcsp, 261 FM_FMRI_HC_SPECIFIC_OFFSET, &eroff) != 0 && 262 nvlist_lookup_uint64(hcsp, "asru-" FM_FMRI_HC_SPECIFIC_OFFSET, 263 &eroff) != 0)) 264 return (1); 265 266 /* 267 * special case for page fmri: return true if ee is the same page 268 */ 269 if (nvlist_lookup_nvlist(ee, FM_FMRI_HC_SPECIFIC, &hcsp) == 0 && 270 (nvlist_lookup_uint64(hcsp, FM_FMRI_HC_SPECIFIC_OFFSET, 271 &eeoff) == 0 || nvlist_lookup_uint64(hcsp, "asru-" 272 FM_FMRI_HC_SPECIFIC_OFFSET, &eeoff) == 0) && eroff == eeoff) 273 return (1); 274 275 return (0); 276 } 277 278 int 279 fmd_fmri_service_state(nvlist_t *nvl) 280 { 281 uint8_t version; 282 int err, service_state; 283 topo_hdl_t *thp; 284 285 if (nvlist_lookup_uint8(nvl, FM_VERSION, &version) != 0 || 286 version > FM_DEV_SCHEME_VERSION) 287 return (fmd_fmri_set_errno(EINVAL)); 288 289 if ((thp = fmd_fmri_topo_hold(TOPO_VERSION)) == NULL) 290 return (fmd_fmri_set_errno(EINVAL)); 291 err = 0; 292 service_state = topo_fmri_service_state(thp, nvl, &err); 293 fmd_fmri_topo_rele(thp); 294 295 if (err != 0) 296 return (FMD_SERVICE_STATE_UNKNOWN); 297 else 298 return (service_state); 299 } 300