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 /* 23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * I/O support routines for DR 29 */ 30 31 #include <sys/types.h> 32 #include <sys/cmn_err.h> 33 #include <sys/debug.h> 34 #include <sys/errno.h> 35 #include <sys/dditypes.h> 36 #include <sys/ddi.h> 37 #include <sys/sunddi.h> 38 #include <sys/sunndi.h> 39 #include <sys/ndi_impldefs.h> 40 #include <sys/kmem.h> 41 #include <sys/promif.h> 42 #include <sys/sysmacros.h> 43 #include <sys/archsystm.h> 44 #include <sys/machsystm.h> 45 46 #include <sys/dr.h> 47 #include <sys/dr_util.h> 48 #include <sys/drmach.h> 49 50 void 51 dr_init_io_unit(dr_io_unit_t *ip) 52 { 53 dr_state_t new_state; 54 55 if (DR_DEV_IS_ATTACHED(&ip->sbi_cm)) { 56 new_state = DR_STATE_CONFIGURED; 57 ip->sbi_cm.sbdev_cond = SBD_COND_OK; 58 } else if (DR_DEV_IS_PRESENT(&ip->sbi_cm)) { 59 new_state = DR_STATE_CONNECTED; 60 ip->sbi_cm.sbdev_cond = SBD_COND_OK; 61 } else { 62 new_state = DR_STATE_EMPTY; 63 } 64 dr_device_transition(&ip->sbi_cm, new_state); 65 } 66 67 /*ARGSUSED*/ 68 void 69 dr_attach_io(dr_handle_t *hp, dr_common_unit_t *cp) 70 { 71 sbd_error_t *err; 72 73 dr_lock_status(hp->h_bd); 74 err = drmach_configure(cp->sbdev_id, 0); 75 dr_unlock_status(hp->h_bd); 76 77 if (!err) 78 err = drmach_io_post_attach(cp->sbdev_id); 79 80 if (err) 81 DRERR_SET_C(&cp->sbdev_error, &err); 82 } 83 84 /* 85 * remove device nodes for the branch indicated by cp 86 */ 87 /*ARGSUSED*/ 88 void 89 dr_detach_io(dr_handle_t *hp, dr_common_unit_t *cp) 90 { 91 sbd_error_t *err; 92 93 err = drmach_unconfigure(cp->sbdev_id, 0); 94 95 if (!err) 96 err = drmach_unconfigure(cp->sbdev_id, DEVI_BRANCH_DESTROY); 97 98 if (!err) 99 err = drmach_io_post_release(cp->sbdev_id); 100 101 if (err) { 102 dr_device_transition(cp, DR_STATE_CONFIGURED); 103 DRERR_SET_C(&cp->sbdev_error, &err); 104 } 105 } 106 107 /*ARGSUSED*/ 108 int 109 dr_disconnect_io(dr_io_unit_t *ip) 110 { 111 return (0); 112 } 113 114 /*ARGSUSED*/ 115 int 116 dr_pre_attach_io(dr_handle_t *hp, 117 dr_common_unit_t **devlist, int devnum) 118 { 119 int d; 120 121 for (d = 0; d < devnum; d++) { 122 dr_common_unit_t *cp = devlist[d]; 123 124 cmn_err(CE_CONT, "OS configure %s", cp->sbdev_path); 125 } 126 127 return (0); 128 } 129 130 /*ARGSUSED*/ 131 int 132 dr_post_attach_io(dr_handle_t *hp, 133 dr_common_unit_t **devlist, int devnum) 134 { 135 return (0); 136 } 137 138 static int 139 dr_check_io_refs(dr_handle_t *hp, dr_common_unit_t **devlist, int devnum) 140 { 141 register int i, reftotal = 0; 142 static fn_t f = "dr_check_io_refs"; 143 144 for (i = 0; i < devnum; i++) { 145 dr_io_unit_t *ip = (dr_io_unit_t *)devlist[i]; 146 dev_info_t *dip; 147 int ref; 148 int refcount_non_gldv3; 149 sbd_error_t *err; 150 151 err = drmach_get_dip(ip->sbi_cm.sbdev_id, &dip); 152 if (err) 153 DRERR_SET_C(&ip->sbi_cm.sbdev_error, &err); 154 else if (dip != NULL) { 155 ref = 0; 156 refcount_non_gldv3 = 0; 157 ASSERT(e_ddi_branch_held(dip)); 158 dr_check_devices(dip, &ref, hp, NULL, NULL, 159 0, &refcount_non_gldv3); 160 ASSERT(refcount_non_gldv3 >= 0); 161 ASSERT(ref >= refcount_non_gldv3); 162 /* 163 * Ignore reference counts of non-gldv3 network devices 164 * as Crossbow creates reference counts for non-active 165 * (unplumbed) instances. Reference count check in 166 * detach() known to prevent device from detaching 167 * as necessary. 168 */ 169 ref -= refcount_non_gldv3; 170 hp->h_err = NULL; 171 if (ref) { 172 dr_dev_err(CE_WARN, &ip->sbi_cm, ESBD_BUSY); 173 } 174 PR_IO("%s: dip(%s) ref = %d\n", 175 f, ddi_get_name(dip), ref); 176 reftotal += ref; 177 } else { 178 PR_IO("%s: NO dip for id (0x%x)\n", 179 f, (uint_t)(uintptr_t)ip->sbi_cm.sbdev_id); 180 } 181 } 182 183 return (reftotal); 184 } 185 186 int 187 dr_pre_release_io(dr_handle_t *hp, 188 dr_common_unit_t **devlist, int devnum) 189 { 190 static fn_t f = "dr_pre_release_io"; 191 int d; 192 193 ASSERT(devnum > 0); 194 195 /* fail if any I/O device pre-release fails */ 196 for (d = 0; d < devnum; d++) { 197 dr_io_unit_t *ip = (dr_io_unit_t *)devlist[d]; 198 199 if ((hp->h_err = drmach_io_pre_release( 200 ip->sbi_cm.sbdev_id)) != 0) { 201 return (-1); 202 } 203 } 204 205 for (d = 0; d < devnum; d++) { 206 dr_io_unit_t *ip = (dr_io_unit_t *)devlist[d]; 207 sbd_error_t *err; 208 209 err = drmach_release(ip->sbi_cm.sbdev_id); 210 if (err) { 211 DRERR_SET_C(&ip->sbi_cm.sbdev_error, 212 &err); 213 return (-1); 214 } 215 } 216 217 /* fail if any I/O devices are still referenced */ 218 if (dr_check_io_refs(hp, devlist, devnum) > 0) { 219 PR_IO("%s: failed - I/O devices ref'd\n", f); 220 221 /* recover before return error */ 222 for (d = 0; d < devnum; d++) { 223 dr_io_unit_t *ip = (dr_io_unit_t *)devlist[d]; 224 sbd_error_t *err; 225 err = drmach_io_unrelease(ip->sbi_cm.sbdev_id); 226 if (err) { 227 DRERR_SET_C(&ip->sbi_cm.sbdev_error, &err); 228 return (-1); 229 } 230 } 231 return (-1); 232 } 233 return (0); 234 } 235 236 /*ARGSUSED*/ 237 int 238 dr_pre_detach_io(dr_handle_t *hp, 239 dr_common_unit_t **devlist, int devnum) 240 { 241 int d; 242 243 ASSERT(devnum > 0); 244 245 for (d = 0; d < devnum; d++) { 246 dr_common_unit_t *cp = devlist[d]; 247 248 cmn_err(CE_CONT, "OS unconfigure %s", cp->sbdev_path); 249 } 250 251 return (0); 252 } 253 254 /*ARGSUSED*/ 255 int 256 dr_post_detach_io(dr_handle_t *hp, dr_common_unit_t **devlist, int devnum) 257 { 258 register int i; 259 int rv = 0; 260 static fn_t f = "dr_post_detach_io"; 261 262 ASSERT(devnum > 0); 263 for (i = 0; i < devnum; i++) { 264 dr_common_unit_t *cp = devlist[i]; 265 if (cp->sbdev_error != NULL) { 266 PR_IO("%s: Failed\n", f); 267 rv = -1; 268 break; 269 } 270 } 271 return (rv); 272 } 273 274 static void 275 dr_get_comp_cond(dr_io_unit_t *ip, dev_info_t *dip) 276 { 277 if (dip == NULL) { 278 ip->sbi_cm.sbdev_cond = SBD_COND_UNKNOWN; 279 return; 280 } 281 282 if (DEVI(dip)->devi_flags & DEVI_RETIRED) { 283 ip->sbi_cm.sbdev_cond = SBD_COND_FAILED; 284 return; 285 } 286 287 if (DR_DEV_IS_ATTACHED(&ip->sbi_cm)) { 288 ip->sbi_cm.sbdev_cond = SBD_COND_OK; 289 } else if (DR_DEV_IS_PRESENT(&ip->sbi_cm)) { 290 ip->sbi_cm.sbdev_cond = SBD_COND_OK; 291 } 292 } 293 294 int 295 dr_io_status(dr_handle_t *hp, dr_devset_t devset, sbd_dev_stat_t *dsp) 296 { 297 int i, ix; 298 dr_board_t *bp; 299 sbd_io_stat_t *isp; 300 dr_io_unit_t *ip; 301 302 bp = hp->h_bd; 303 304 /* 305 * Only look for requested devices that are actually present. 306 */ 307 devset &= DR_DEVS_PRESENT(bp); 308 309 for (i = ix = 0; i < MAX_IO_UNITS_PER_BOARD; i++) { 310 drmachid_t id; 311 dev_info_t *dip; 312 sbd_error_t *err; 313 drmach_status_t pstat; 314 315 if (DEVSET_IN_SET(devset, SBD_COMP_IO, i) == 0) 316 continue; 317 318 ip = dr_get_io_unit(bp, i); 319 320 if (ip->sbi_cm.sbdev_state == DR_STATE_EMPTY) { 321 /* present, but not fully initialized */ 322 continue; 323 } 324 325 id = ip->sbi_cm.sbdev_id; 326 if (id == (drmachid_t)0) 327 continue; 328 329 err = drmach_status(ip->sbi_cm.sbdev_id, &pstat); 330 if (err) { 331 DRERR_SET_C(&ip->sbi_cm.sbdev_error, &err); 332 return (-1); 333 } 334 335 dip = NULL; 336 err = drmach_get_dip(id, &dip); 337 if (err) { 338 /* catch this in debug kernels */ 339 ASSERT(0); 340 341 sbd_err_clear(&err); 342 continue; 343 } 344 345 isp = &dsp->d_io; 346 bzero((caddr_t)isp, sizeof (*isp)); 347 348 isp->is_cm.c_id.c_type = ip->sbi_cm.sbdev_type; 349 isp->is_cm.c_id.c_unit = ip->sbi_cm.sbdev_unum; 350 (void) strlcpy(isp->is_cm.c_id.c_name, pstat.type, 351 sizeof (isp->is_cm.c_id.c_name)); 352 353 dr_get_comp_cond(ip, dip); 354 isp->is_cm.c_cond = ip->sbi_cm.sbdev_cond; 355 isp->is_cm.c_busy = ip->sbi_cm.sbdev_busy | pstat.busy; 356 isp->is_cm.c_time = ip->sbi_cm.sbdev_time; 357 isp->is_cm.c_ostate = ip->sbi_cm.sbdev_ostate; 358 isp->is_cm.c_sflags = 0; 359 360 if (dip == NULL) { 361 isp->is_pathname[0] = '\0'; 362 isp->is_referenced = 0; 363 isp->is_unsafe_count = 0; 364 } else { 365 int refcount = 0, idx = 0; 366 uint64_t unsafe_devs[SBD_MAX_UNSAFE]; 367 368 ASSERT(e_ddi_branch_held(dip)); 369 (void) ddi_pathname(dip, isp->is_pathname); 370 371 /* check reference and unsafe counts on devices */ 372 isp->is_unsafe_count = 0; 373 dr_check_devices(dip, &refcount, hp, unsafe_devs, 374 &idx, SBD_MAX_UNSAFE, NULL); 375 while (idx > 0) { 376 isp->is_unsafe_list[idx-1] = unsafe_devs[idx-1]; 377 --idx; 378 } 379 380 isp->is_referenced = (refcount == 0) ? 0 : 1; 381 382 hp->h_err = NULL; 383 } 384 ix++; 385 dsp++; 386 } 387 388 return (ix); 389 } 390