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