?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel: remove unused utsname_set_machine()
[unleashed.git] / usr / src / uts / sun4v / io / vdc.c
blob77619e38fe3a10e8d3956a6d526bf13d40b790bc
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 (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 /*
27 * LDoms virtual disk client (vdc) device driver
28 *
29 * This driver runs on a guest logical domain and communicates with the virtual
30 * disk server (vds) driver running on the service domain which is exporting
31 * virtualized "disks" to the guest logical domain.
32 *
33 * The driver can be divided into four sections:
34 *
35 * 1) generic device driver housekeeping
36 * _init, _fini, attach, detach, ops structures, etc.
37 *
38 * 2) communication channel setup
39 * Setup the communications link over the LDC channel that vdc uses to
40 * talk to the vDisk server. Initialise the descriptor ring which
41 * allows the LDC clients to transfer data via memory mappings.
42 *
43 * 3) Support exported to upper layers (filesystems, etc)
44 * The upper layers call into vdc via strategy(9E) and DKIO(7I)
45 * ioctl calls. vdc will copy the data to be written to the descriptor
46 * ring or maps the buffer to store the data read by the vDisk
47 * server into the descriptor ring. It then sends a message to the
48 * vDisk server requesting it to complete the operation.
49 *
50 * 4) Handling responses from vDisk server.
51 * The vDisk server will ACK some or all of the messages vdc sends to it
52 * (this is configured during the handshake). Upon receipt of an ACK
53 * vdc will check the descriptor ring and signal to the upper layer
54 * code waiting on the IO.
55 */
56
57 #include <sys/atomic.h>
58 #include <sys/conf.h>
59 #include <sys/disp.h>
60 #include <sys/ddi.h>
61 #include <sys/dkio.h>
62 #include <sys/efi_partition.h>
63 #include <sys/fcntl.h>
64 #include <sys/file.h>
65 #include <sys/kstat.h>
66 #include <sys/mach_descrip.h>
67 #include <sys/modctl.h>
68 #include <sys/mdeg.h>
69 #include <sys/note.h>
70 #include <sys/open.h>
71 #include <sys/random.h>
72 #include <sys/sdt.h>
73 #include <sys/stat.h>
74 #include <sys/sunddi.h>
75 #include <sys/types.h>
76 #include <sys/promif.h>
77 #include <sys/var.h>
78 #include <sys/vtoc.h>
79 #include <sys/archsystm.h>
80 #include <sys/sysmacros.h>
81
82 #include <sys/cdio.h>
83 #include <sys/dktp/fdisk.h>
84 #include <sys/dktp/dadkio.h>
85 #include <sys/fs/dv_node.h>
86 #include <sys/mhd.h>
87 #include <sys/scsi/generic/sense.h>
88 #include <sys/scsi/impl/uscsi.h>
89 #include <sys/scsi/impl/services.h>
90 #include <sys/scsi/targets/sddef.h>
91
92 #include <sys/ldoms.h>
93 #include <sys/ldc.h>
94 #include <sys/vio_common.h>
95 #include <sys/vio_mailbox.h>
96 #include <sys/vio_util.h>
97 #include <sys/vdsk_common.h>
98 #include <sys/vdsk_mailbox.h>
99 #include <sys/vdc.h>
100
101 #define VD_OLDVTOC_LIMIT 0x7fffffff
102
103 /*
104 * function prototypes
105 */
106
107 /* standard driver functions */
108 static int vdc_open(dev_t *dev, int flag, int otyp, cred_t *cred);
109 static int vdc_close(dev_t dev, int flag, int otyp, cred_t *cred);
110 static int vdc_strategy(struct buf *buf);
111 static int vdc_print(dev_t dev, char *str);
112 static int vdc_dump(dev_t dev, caddr_t addr, daddr_t blkno, int nblk);
113 static int vdc_read(dev_t dev, struct uio *uio, cred_t *cred);
114 static int vdc_write(dev_t dev, struct uio *uio, cred_t *cred);
115 static int vdc_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
116 cred_t *credp, int *rvalp);
117 static int vdc_aread(dev_t dev, struct aio_req *aio, cred_t *cred);
118 static int vdc_awrite(dev_t dev, struct aio_req *aio, cred_t *cred);
119
120 static int vdc_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd,
121 void *arg, void **resultp);
122 static int vdc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
123 static int vdc_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
124 static int vdc_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
125 int mod_flags, char *name, caddr_t valuep, int *lengthp);
126
127 /* setup */
128 static void vdc_min(struct buf *bufp);
129 static int vdc_send(vdc_t *vdc, caddr_t pkt, size_t *msglen);
130 static int vdc_do_ldc_init(vdc_t *vdc, vdc_server_t *srvr);
131 static int vdc_start_ldc_connection(vdc_t *vdc);
132 static int vdc_create_device_nodes(vdc_t *vdc);
133 static int vdc_create_device_nodes_efi(vdc_t *vdc);
134 static int vdc_create_device_nodes_vtoc(vdc_t *vdc);
135 static void vdc_create_io_kstats(vdc_t *vdc);
136 static void vdc_create_err_kstats(vdc_t *vdc);
137 static void vdc_set_err_kstats(vdc_t *vdc);
138 static int vdc_get_md_node(dev_info_t *dip, md_t **mdpp,
139 mde_cookie_t *vd_nodep);
140 static int vdc_init_ports(vdc_t *vdc, md_t *mdp, mde_cookie_t vd_nodep);
141 static void vdc_fini_ports(vdc_t *vdc);
142 static void vdc_switch_server(vdc_t *vdcp);
143 static int vdc_do_ldc_up(vdc_t *vdc);
144 static void vdc_terminate_ldc(vdc_t *vdc, vdc_server_t *srvr);
145 static int vdc_init_descriptor_ring(vdc_t *vdc);
146 static void vdc_destroy_descriptor_ring(vdc_t *vdc);
147 static int vdc_setup_devid(vdc_t *vdc);
148 static void vdc_store_label_efi(vdc_t *, efi_gpt_t *, efi_gpe_t *);
149 static void vdc_store_label_vtoc(vdc_t *, struct dk_geom *,
150 struct extvtoc *);
151 static void vdc_store_label_unk(vdc_t *vdc);
152 static boolean_t vdc_is_opened(vdc_t *vdc);
153 static void vdc_update_size(vdc_t *vdc, size_t, size_t, size_t);
154 static int vdc_update_vio_bsize(vdc_t *vdc, uint32_t);
155
156 /* handshake with vds */
157 static int vdc_init_ver_negotiation(vdc_t *vdc, vio_ver_t ver);
158 static int vdc_ver_negotiation(vdc_t *vdcp);
159 static int vdc_init_attr_negotiation(vdc_t *vdc);
160 static int vdc_attr_negotiation(vdc_t *vdcp);
161 static int vdc_init_dring_negotiate(vdc_t *vdc);
162 static int vdc_dring_negotiation(vdc_t *vdcp);
163 static int vdc_send_rdx(vdc_t *vdcp);
164 static int vdc_rdx_exchange(vdc_t *vdcp);
165 static boolean_t vdc_is_supported_version(vio_ver_msg_t *ver_msg);
166
167 /* processing incoming messages from vDisk server */
168 static void vdc_process_msg_thread(vdc_t *vdc);
169 static int vdc_recv(vdc_t *vdc, vio_msg_t *msgp, size_t *nbytesp);
170
171 static uint_t vdc_handle_cb(uint64_t event, caddr_t arg);
172 static int vdc_process_data_msg(vdc_t *vdc, vio_msg_t *msg);
173 static int vdc_handle_ver_msg(vdc_t *vdc, vio_ver_msg_t *ver_msg);
174 static int vdc_handle_attr_msg(vdc_t *vdc, vd_attr_msg_t *attr_msg);
175 static int vdc_handle_dring_reg_msg(vdc_t *vdc, vio_dring_reg_msg_t *msg);
176 static int vdc_send_request(vdc_t *vdcp, int operation,
177 caddr_t addr, size_t nbytes, int slice, diskaddr_t offset,
178 buf_t *bufp, vio_desc_direction_t dir, int flags);
179 static int vdc_map_to_shared_dring(vdc_t *vdcp, int idx);
180 static int vdc_populate_descriptor(vdc_t *vdcp, int operation,
181 caddr_t addr, size_t nbytes, int slice, diskaddr_t offset,
182 buf_t *bufp, vio_desc_direction_t dir, int flags);
183 static int vdc_do_sync_op(vdc_t *vdcp, int operation, caddr_t addr,
184 size_t nbytes, int slice, diskaddr_t offset,
185 vio_desc_direction_t dir, boolean_t);
186 static int vdc_do_op(vdc_t *vdc, int op, caddr_t addr, size_t nbytes,
187 int slice, diskaddr_t offset, struct buf *bufp,
188 vio_desc_direction_t dir, int flags);
189
190 static int vdc_wait_for_response(vdc_t *vdcp, vio_msg_t *msgp);
191 static int vdc_drain_response(vdc_t *vdcp, struct buf *buf);
192 static int vdc_depopulate_descriptor(vdc_t *vdc, uint_t idx);
193 static int vdc_populate_mem_hdl(vdc_t *vdcp, vdc_local_desc_t *ldep);
194 static int vdc_verify_seq_num(vdc_t *vdc, vio_dring_msg_t *dring_msg);
195
196 /* dkio */
197 static int vd_process_ioctl(dev_t dev, int cmd, caddr_t arg, int mode,
198 int *rvalp);
199 static int vd_process_efi_ioctl(void *vdisk, int cmd, uintptr_t arg);
200 static void vdc_create_fake_geometry(vdc_t *vdc);
201 static int vdc_validate_geometry(vdc_t *vdc);
202 static void vdc_validate(vdc_t *vdc);
203 static void vdc_validate_task(void *arg);
204 static int vdc_null_copy_func(vdc_t *vdc, void *from, void *to,
205 int mode, int dir);
206 static int vdc_get_wce_convert(vdc_t *vdc, void *from, void *to,
207 int mode, int dir);
208 static int vdc_set_wce_convert(vdc_t *vdc, void *from, void *to,
209 int mode, int dir);
210 static int vdc_get_vtoc_convert(vdc_t *vdc, void *from, void *to,
211 int mode, int dir);
212 static int vdc_set_vtoc_convert(vdc_t *vdc, void *from, void *to,
213 int mode, int dir);
214 static int vdc_get_extvtoc_convert(vdc_t *vdc, void *from, void *to,
215 int mode, int dir);
216 static int vdc_set_extvtoc_convert(vdc_t *vdc, void *from, void *to,
217 int mode, int dir);
218 static int vdc_get_geom_convert(vdc_t *vdc, void *from, void *to,
219 int mode, int dir);
220 static int vdc_set_geom_convert(vdc_t *vdc, void *from, void *to,
221 int mode, int dir);
222 static int vdc_get_efi_convert(vdc_t *vdc, void *from, void *to,
223 int mode, int dir);
224 static int vdc_set_efi_convert(vdc_t *vdc, void *from, void *to,
225 int mode, int dir);
226
227 static void vdc_ownership_update(vdc_t *vdc, int ownership_flags);
228 static int vdc_access_set(vdc_t *vdc, uint64_t flags);
229 static vdc_io_t *vdc_eio_queue(vdc_t *vdc, int index);
230 static void vdc_eio_unqueue(vdc_t *vdc, clock_t deadline,
231 boolean_t complete_io);
232 static int vdc_eio_check(vdc_t *vdc, int flags);
233 static void vdc_eio_thread(void *arg);
234
235 /*
236 * Module variables
237 */
238
239 /*
240 * Number of handshake retries with the current server before switching to
241 * a different server. These retries are done so that we stick with the same
242 * server if vdc receives a LDC reset event during the initiation of the
243 * handshake. This can happen if vdc reset the LDC channel and then immediately
244 * retry a connexion before it has received the LDC reset event.
245 *
246 * If there is only one server then we "switch" to the same server. We also
247 * switch if the handshake has reached the attribute negotiate step whatever
248 * the number of handshake retries might be.
249 */
250 static uint_t vdc_hshake_retries = VDC_HSHAKE_RETRIES;
251
252 /*
253 * If the handshake done during the attach fails then the two following
254 * variables will also be used to control the number of retries for the
255 * next handshakes. In that case, when a handshake is done after the
256 * attach (i.e. the vdc lifecycle is VDC_ONLINE_PENDING) then the handshake
257 * will be retried until we have done an attribution negotiation with each
258 * server, with a specified minimum total number of negotations (the value
259 * of the vdc_hattr_min_initial or vdc_hattr_min variable).
260 *
261 * This prevents new I/Os on a newly used vdisk to block forever if the
262 * attribute negotiations can not be done, and to limit the amount of time
263 * before I/Os will fail. Basically, attribute negotiations will fail when
264 * the service is up but the backend does not exist. In that case, vds will
265 * typically retry to access the backend during 50 seconds. So I/Os will fail
266 * after the following amount of time:
267 *
268 * 50 seconds x max(number of servers, vdc->hattr_min)
269 *
270 * After that the handshake done during the attach has failed then the next
271 * handshake will use vdc_attr_min_initial. This handshake will correspond to
272 * the very first I/O to the device. If this handshake also fails then
273 * vdc_hattr_min will be used for subsequent handshakes. We typically allow
274 * more retries for the first handshake (VDC_HATTR_MIN_INITIAL = 3) to give more
275 * time for the backend to become available (50s x VDC_HATTR_MIN_INITIAL = 150s)
276 * in case this is a critical vdisk (e.g. vdisk access during boot). Then we use
277 * a smaller value (VDC_HATTR_MIN = 1) to avoid waiting too long for each I/O.
278 */
279 static uint_t vdc_hattr_min_initial = VDC_HATTR_MIN_INITIAL;
280 static uint_t vdc_hattr_min = VDC_HATTR_MIN;
281
282 /*
283 * Tunable variables to control how long vdc waits before timing out on
284 * various operations
285 */
286 static int vdc_timeout = 0; /* units: seconds */
287 static int vdc_ldcup_timeout = 1; /* units: seconds */
288
289 static uint64_t vdc_hz_min_ldc_delay;
290 static uint64_t vdc_min_timeout_ldc = 1 * MILLISEC;
291 static uint64_t vdc_hz_max_ldc_delay;
292 static uint64_t vdc_max_timeout_ldc = 100 * MILLISEC;
293
294 static uint64_t vdc_ldc_read_init_delay = 1 * MILLISEC;
295 static uint64_t vdc_ldc_read_max_delay = 100 * MILLISEC;
296
297 /* values for dumping - need to run in a tighter loop */
298 static uint64_t vdc_usec_timeout_dump = 100 * MILLISEC; /* 0.1s units: ns */
299 static int vdc_dump_retries = 100;
300
301 static uint16_t vdc_scsi_timeout = 60; /* 60s units: seconds */
302
303 static uint64_t vdc_ownership_delay = 6 * MICROSEC; /* 6s units: usec */
304
305 /* Count of the number of vdc instances attached */
306 static volatile uint32_t vdc_instance_count = 0;
307
308 /* Tunable to log all SCSI errors */
309 static boolean_t vdc_scsi_log_error = B_FALSE;
310
311 /* Soft state pointer */
312 static void *vdc_state;
313
314 /*
315 * Controlling the verbosity of the error/debug messages
316 *
317 * vdc_msglevel - controls level of messages
318 * vdc_matchinst - 64-bit variable where each bit corresponds
319 * to the vdc instance the vdc_msglevel applies.
320 */
321 int vdc_msglevel = 0x0;
322 uint64_t vdc_matchinst = 0ull;
323
324 /*
325 * Supported vDisk protocol version pairs.
326 *
327 * The first array entry is the latest and preferred version.
328 */
329 static const vio_ver_t vdc_version[] = {{1, 1}};
330
331 static struct cb_ops vdc_cb_ops = {
332 vdc_open, /* cb_open */
333 vdc_close, /* cb_close */
334 vdc_strategy, /* cb_strategy */
335 vdc_print, /* cb_print */
336 vdc_dump, /* cb_dump */
337 vdc_read, /* cb_read */
338 vdc_write, /* cb_write */
339 vdc_ioctl, /* cb_ioctl */
340 nodev, /* cb_devmap */
341 nodev, /* cb_mmap */
342 nodev, /* cb_segmap */
343 nochpoll, /* cb_chpoll */
344 vdc_prop_op, /* cb_prop_op */
345 NULL, /* cb_str */
346 D_MP | D_64BIT, /* cb_flag */
347 CB_REV, /* cb_rev */
348 vdc_aread, /* cb_aread */
349 vdc_awrite /* cb_awrite */
350 };
351
352 static struct dev_ops vdc_ops = {
353 DEVO_REV, /* devo_rev */
354 0, /* devo_refcnt */
355 vdc_getinfo, /* devo_getinfo */
356 nulldev, /* devo_identify */
357 nulldev, /* devo_probe */
358 vdc_attach, /* devo_attach */
359 vdc_detach, /* devo_detach */
360 nodev, /* devo_reset */
361 &vdc_cb_ops, /* devo_cb_ops */
362 NULL, /* devo_bus_ops */
363 nulldev, /* devo_power */
364 ddi_quiesce_not_needed, /* devo_quiesce */
365 };
366
367 static struct modldrv modldrv = {
368 &mod_driverops,
369 "virtual disk client",
370 &vdc_ops,
371 };
372
373 static struct modlinkage modlinkage = {
374 MODREV_1,
375 &modldrv,
376 NULL
377 };
378
379 /* -------------------------------------------------------------------------- */
380
381 /*
382 * Device Driver housekeeping and setup
383 */
384
385 int
386 _init(void)
387 {
388 int status;
389
390 if ((status = ddi_soft_state_init(&vdc_state, sizeof (vdc_t), 1)) != 0)
391 return (status);
392 if ((status = mod_install(&modlinkage)) != 0)
393 ddi_soft_state_fini(&vdc_state);
394 return (status);
395 }
396
397 int
398 _info(struct modinfo *modinfop)
399 {
400 return (mod_info(&modlinkage, modinfop));
401 }
402
403 int
404 _fini(void)
405 {
406 int status;
407
408 if ((status = mod_remove(&modlinkage)) != 0)
409 return (status);
410 ddi_soft_state_fini(&vdc_state);
411 return (0);
412 }
413
414 static int
415 vdc_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resultp)
416 {
417 _NOTE(ARGUNUSED(dip))
418
419 int instance = VDCUNIT((dev_t)arg);
420 vdc_t *vdc = NULL;
421
422 switch (cmd) {
423 case DDI_INFO_DEVT2DEVINFO:
424 if ((vdc = ddi_get_soft_state(vdc_state, instance)) == NULL) {
425 *resultp = NULL;
426 return (DDI_FAILURE);
427 }
428 *resultp = vdc->dip;
429 return (DDI_SUCCESS);
430 case DDI_INFO_DEVT2INSTANCE:
431 *resultp = (void *)(uintptr_t)instance;
432 return (DDI_SUCCESS);
433 default:
434 *resultp = NULL;
435 return (DDI_FAILURE);
436 }
437 }
438
439 static int
440 vdc_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
441 {
442 kt_did_t eio_tid, ownership_tid;
443 int instance;
444 int rv;
445 vdc_server_t *srvr;
446 vdc_t *vdc = NULL;
447
448 switch (cmd) {
449 case DDI_DETACH:
450 /* the real work happens below */
451 break;
452 case DDI_SUSPEND:
453 /* nothing to do for this non-device */
454 return (DDI_SUCCESS);
455 default:
456 return (DDI_FAILURE);
457 }
458
459 ASSERT(cmd == DDI_DETACH);
460 instance = ddi_get_instance(dip);
461 DMSGX(1, "[%d] Entered\n", instance);
462
463 if ((vdc = ddi_get_soft_state(vdc_state, instance)) == NULL) {
464 cmn_err(CE_NOTE, "[%d] Couldn't get state structure", instance);
465 return (DDI_FAILURE);
466 }
467
468 if (vdc_is_opened(vdc)) {
469 DMSG(vdc, 0, "[%d] Cannot detach: device is open", instance);
470 return (DDI_FAILURE);
471 }
472
473 if (vdc->dkio_flush_pending) {
474 DMSG(vdc, 0,
475 "[%d] Cannot detach: %d outstanding DKIO flushes\n",
476 instance, vdc->dkio_flush_pending);
477 return (DDI_FAILURE);
478 }
479
480 if (vdc->validate_pending) {
481 DMSG(vdc, 0,
482 "[%d] Cannot detach: %d outstanding validate request\n",
483 instance, vdc->validate_pending);
484 return (DDI_FAILURE);
485 }
486
487 DMSG(vdc, 0, "[%d] proceeding...\n", instance);
488
489 /* If we took ownership, release ownership */
490 mutex_enter(&vdc->ownership_lock);
491 if (vdc->ownership & VDC_OWNERSHIP_GRANTED) {
492 rv = vdc_access_set(vdc, VD_ACCESS_SET_CLEAR);
493 if (rv == 0) {
494 vdc_ownership_update(vdc, VDC_OWNERSHIP_NONE);
495 }
496 }
497 mutex_exit(&vdc->ownership_lock);
498
499 /* mark instance as detaching */
500 mutex_enter(&vdc->lock);
501 vdc->lifecycle = VDC_LC_DETACHING;
502 mutex_exit(&vdc->lock);
503
504 /*
505 * Try and disable callbacks to prevent another handshake. We have to
506 * disable callbacks for all servers.
507 */
508 for (srvr = vdc->server_list; srvr != NULL; srvr = srvr->next) {
509 rv = ldc_set_cb_mode(srvr->ldc_handle, LDC_CB_DISABLE);
510 DMSG(vdc, 0, "callback disabled (ldc=%lu, rv=%d)\n",
511 srvr->ldc_id, rv);
512 }
513
514 if (vdc->initialized & VDC_THREAD) {
515 mutex_enter(&vdc->read_lock);
516 if ((vdc->read_state == VDC_READ_WAITING) ||
517 (vdc->read_state == VDC_READ_RESET)) {
518 vdc->read_state = VDC_READ_RESET;
519 cv_signal(&vdc->read_cv);
520 }
521
522 mutex_exit(&vdc->read_lock);
523
524 /* wake up any thread waiting for connection to come online */
525 mutex_enter(&vdc->lock);
526 if (vdc->state == VDC_STATE_INIT_WAITING) {
527 DMSG(vdc, 0,
528 "[%d] write reset - move to resetting state...\n",
529 instance);
530 vdc->state = VDC_STATE_RESETTING;
531 cv_signal(&vdc->initwait_cv);
532 } else if (vdc->state == VDC_STATE_FAILED) {
533 vdc->io_pending = B_TRUE;
534 cv_signal(&vdc->io_pending_cv);
535 }
536 mutex_exit(&vdc->lock);
537
538 /* now wait until state transitions to VDC_STATE_DETACH */
539 thread_join(vdc->msg_proc_thr->t_did);
540 ASSERT(vdc->state == VDC_STATE_DETACH);
541 DMSG(vdc, 0, "[%d] Reset thread exit and join ..\n",
542 vdc->instance);
543 }
544
545 mutex_enter(&vdc->lock);
546
547 if (vdc->initialized & VDC_DRING)
548 vdc_destroy_descriptor_ring(vdc);
549
550 vdc_fini_ports(vdc);
551
552 if (vdc->eio_thread) {
553 eio_tid = vdc->eio_thread->t_did;
554 vdc->failfast_interval = 0;
555 ASSERT(vdc->num_servers == 0);
556 cv_signal(&vdc->eio_cv);
557 } else {
558 eio_tid = 0;
559 }
560
561 if (vdc->ownership & VDC_OWNERSHIP_WANTED) {
562 ownership_tid = vdc->ownership_thread->t_did;
563 vdc->ownership = VDC_OWNERSHIP_NONE;
564 cv_signal(&vdc->ownership_cv);
565 } else {
566 ownership_tid = 0;
567 }
568
569 mutex_exit(&vdc->lock);
570
571 if (eio_tid != 0)
572 thread_join(eio_tid);
573
574 if (ownership_tid != 0)
575 thread_join(ownership_tid);
576
577 if (vdc->initialized & VDC_MINOR)
578 ddi_remove_minor_node(dip, NULL);
579
580 if (vdc->io_stats) {
581 kstat_delete(vdc->io_stats);
582 vdc->io_stats = NULL;
583 }
584
585 if (vdc->err_stats) {
586 kstat_delete(vdc->err_stats);
587 vdc->err_stats = NULL;
588 }
589
590 if (vdc->initialized & VDC_LOCKS) {
591 mutex_destroy(&vdc->lock);
592 mutex_destroy(&vdc->read_lock);
593 mutex_destroy(&vdc->ownership_lock);
594 cv_destroy(&vdc->initwait_cv);
595 cv_destroy(&vdc->dring_free_cv);
596 cv_destroy(&vdc->membind_cv);
597 cv_destroy(&vdc->sync_blocked_cv);
598 cv_destroy(&vdc->read_cv);
599 cv_destroy(&vdc->running_cv);
600 cv_destroy(&vdc->io_pending_cv);
601 cv_destroy(&vdc->ownership_cv);
602 cv_destroy(&vdc->eio_cv);
603 }
604
605 if (vdc->minfo)
606 kmem_free(vdc->minfo, sizeof (struct dk_minfo));
607
608 if (vdc->cinfo)
609 kmem_free(vdc->cinfo, sizeof (struct dk_cinfo));
610
611 if (vdc->vtoc)
612 kmem_free(vdc->vtoc, sizeof (struct extvtoc));
613
614 if (vdc->geom)
615 kmem_free(vdc->geom, sizeof (struct dk_geom));
616
617 if (vdc->devid) {
618 ddi_devid_unregister(dip);
619 ddi_devid_free(vdc->devid);
620 }
621
622 if (vdc->initialized & VDC_SOFT_STATE)
623 ddi_soft_state_free(vdc_state, instance);
624
625 DMSG(vdc, 0, "[%d] End %p\n", instance, (void *)vdc);
626
627 return (DDI_SUCCESS);
628 }
629
630
631 static int
632 vdc_do_attach(dev_info_t *dip)
633 {
634 int instance;
635 vdc_t *vdc = NULL;
636 int status;
637 md_t *mdp;
638 mde_cookie_t vd_node;
639
640 ASSERT(dip != NULL);
641
642 instance = ddi_get_instance(dip);
643 if (ddi_soft_state_zalloc(vdc_state, instance) != DDI_SUCCESS) {
644 cmn_err(CE_NOTE, "[%d] Couldn't alloc state structure",
645 instance);
646 return (DDI_FAILURE);
647 }
648
649 if ((vdc = ddi_get_soft_state(vdc_state, instance)) == NULL) {
650 cmn_err(CE_NOTE, "[%d] Couldn't get state structure", instance);
651 return (DDI_FAILURE);
652 }
653
654 /*
655 * We assign the value to initialized in this case to zero out the
656 * variable and then set bits in it to indicate what has been done
657 */
658 vdc->initialized = VDC_SOFT_STATE;
659
660 vdc_hz_min_ldc_delay = drv_usectohz(vdc_min_timeout_ldc);
661 vdc_hz_max_ldc_delay = drv_usectohz(vdc_max_timeout_ldc);
662
663 vdc->dip = dip;
664 vdc->instance = instance;
665 vdc->vdisk_type = VD_DISK_TYPE_UNK;
666 vdc->vdisk_label = VD_DISK_LABEL_UNK;
667 vdc->state = VDC_STATE_INIT;
668 vdc->lifecycle = VDC_LC_ATTACHING;
669 vdc->session_id = 0;
670 vdc->vdisk_bsize = DEV_BSIZE;
671 vdc->vio_bmask = 0;
672 vdc->vio_bshift = 0;
673 vdc->max_xfer_sz = maxphys / vdc->vdisk_bsize;
674
675 /*
676 * We assume, for now, that the vDisk server will export 'read'
677 * operations to us at a minimum (this is needed because of checks
678 * in vdc for supported operations early in the handshake process).
679 * The vDisk server will return ENOTSUP if this is not the case.
680 * The value will be overwritten during the attribute exchange with
681 * the bitmask of operations exported by server.
682 */
683 vdc->operations = VD_OP_MASK_READ;
684
685 vdc->vtoc = NULL;
686 vdc->geom = NULL;
687 vdc->cinfo = NULL;
688 vdc->minfo = NULL;
689
690 mutex_init(&vdc->lock, NULL, MUTEX_DRIVER, NULL);
691 cv_init(&vdc->initwait_cv, NULL, CV_DRIVER, NULL);
692 cv_init(&vdc->dring_free_cv, NULL, CV_DRIVER, NULL);
693 cv_init(&vdc->membind_cv, NULL, CV_DRIVER, NULL);
694 cv_init(&vdc->running_cv, NULL, CV_DRIVER, NULL);
695 cv_init(&vdc->io_pending_cv, NULL, CV_DRIVER, NULL);
696
697 vdc->io_pending = B_FALSE;
698 vdc->threads_pending = 0;
699 vdc->sync_op_blocked = B_FALSE;
700 cv_init(&vdc->sync_blocked_cv, NULL, CV_DRIVER, NULL);
701
702 mutex_init(&vdc->ownership_lock, NULL, MUTEX_DRIVER, NULL);
703 cv_init(&vdc->ownership_cv, NULL, CV_DRIVER, NULL);
704 cv_init(&vdc->eio_cv, NULL, CV_DRIVER, NULL);
705
706 /* init blocking msg read functionality */
707 mutex_init(&vdc->read_lock, NULL, MUTEX_DRIVER, NULL);
708 cv_init(&vdc->read_cv, NULL, CV_DRIVER, NULL);
709 vdc->read_state = VDC_READ_IDLE;
710
711 vdc->initialized |= VDC_LOCKS;
712
713 /* get device and port MD node for this disk instance */
714 if (vdc_get_md_node(dip, &mdp, &vd_node) != 0) {
715 cmn_err(CE_NOTE, "[%d] Could not get machine description node",
716 instance);
717 return (DDI_FAILURE);
718 }
719
720 if (vdc_init_ports(vdc, mdp, vd_node) != 0) {
721 cmn_err(CE_NOTE, "[%d] Error initialising ports", instance);
722 return (DDI_FAILURE);
723 }
724
725 (void) md_fini_handle(mdp);
726
727 /* Create the kstats for saving the I/O statistics used by iostat(1M) */
728 vdc_create_io_kstats(vdc);
729 vdc_create_err_kstats(vdc);
730
731 /* Initialize remaining structures before starting the msg thread */
732 vdc->vdisk_label = VD_DISK_LABEL_UNK;
733 vdc->vtoc = kmem_zalloc(sizeof (struct extvtoc), KM_SLEEP);
734 vdc->geom = kmem_zalloc(sizeof (struct dk_geom), KM_SLEEP);
735 vdc->minfo = kmem_zalloc(sizeof (struct dk_minfo), KM_SLEEP);
736
737 /* initialize the thread responsible for managing state with server */
738 vdc->msg_proc_thr = thread_create(NULL, 0, vdc_process_msg_thread,
739 vdc, 0, &p0, TS_RUN, minclsyspri);
740 if (vdc->msg_proc_thr == NULL) {
741 cmn_err(CE_NOTE, "[%d] Failed to create msg processing thread",
742 instance);
743 return (DDI_FAILURE);
744 }
745
746 /*
747 * If there are multiple servers then start the eio thread.
748 */
749 if (vdc->num_servers > 1) {
750 vdc->eio_thread = thread_create(NULL, 0, vdc_eio_thread, vdc, 0,
751 &p0, TS_RUN, v.v_maxsyspri - 2);
752 if (vdc->eio_thread == NULL) {
753 cmn_err(CE_NOTE, "[%d] Failed to create error "
754 "I/O thread", instance);
755 return (DDI_FAILURE);
756 }
757 }
758
759 vdc->initialized |= VDC_THREAD;
760
761 atomic_inc_32(&vdc_instance_count);
762
763 /*
764 * Check the disk label. This will send requests and do the handshake.
765 * We don't really care about the disk label now. What we really need is
766 * the handshake do be done so that we know the type of the disk (slice
767 * or full disk) and the appropriate device nodes can be created.
768 */
769
770 mutex_enter(&vdc->lock);
771 (void) vdc_validate_geometry(vdc);
772 mutex_exit(&vdc->lock);
773
774 /*
775 * Now that we have the device info we can create the device nodes
776 */
777 status = vdc_create_device_nodes(vdc);
778 if (status) {
779 DMSG(vdc, 0, "[%d] Failed to create device nodes",
780 instance);
781 goto return_status;
782 }
783
784 /*
785 * Fill in the fields of the error statistics kstat that were not
786 * available when creating the kstat
787 */
788 vdc_set_err_kstats(vdc);
789 ddi_report_dev(dip);
790 ASSERT(vdc->lifecycle == VDC_LC_ONLINE ||
791 vdc->lifecycle == VDC_LC_ONLINE_PENDING);
792 DMSG(vdc, 0, "[%d] Attach tasks successful\n", instance);
793
794 return_status:
795 DMSG(vdc, 0, "[%d] Attach completed\n", instance);
796 return (status);
797 }
798
799 static int
800 vdc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
801 {
802 int status;
803
804 switch (cmd) {
805 case DDI_ATTACH:
806 if ((status = vdc_do_attach(dip)) != 0)
807 (void) vdc_detach(dip, DDI_DETACH);
808 return (status);
809 case DDI_RESUME:
810 /* nothing to do for this non-device */
811 return (DDI_SUCCESS);
812 default:
813 return (DDI_FAILURE);
814 }
815 }
816
817 static int
818 vdc_do_ldc_init(vdc_t *vdc, vdc_server_t *srvr)
819 {
820 int status = 0;
821 ldc_status_t ldc_state;
822 ldc_attr_t ldc_attr;
823
824 ASSERT(vdc != NULL);
825 ASSERT(srvr != NULL);
826
827 ldc_attr.devclass = LDC_DEV_BLK;
828 ldc_attr.instance = vdc->instance;
829 ldc_attr.mode = LDC_MODE_UNRELIABLE; /* unreliable transport */
830 ldc_attr.mtu = VD_LDC_MTU;
831
832 if ((srvr->state & VDC_LDC_INIT) == 0) {
833 status = ldc_init(srvr->ldc_id, &ldc_attr,
834 &srvr->ldc_handle);
835 if (status != 0) {
836 DMSG(vdc, 0, "[%d] ldc_init(chan %ld) returned %d",
837 vdc->instance, srvr->ldc_id, status);
838 return (status);
839 }
840 srvr->state |= VDC_LDC_INIT;
841 }
842 status = ldc_status(srvr->ldc_handle, &ldc_state);
843 if (status != 0) {
844 DMSG(vdc, 0, "[%d] Cannot discover LDC status [err=%d]",
845 vdc->instance, status);
846 goto init_exit;
847 }
848 srvr->ldc_state = ldc_state;
849
850 if ((srvr->state & VDC_LDC_CB) == 0) {
851 status = ldc_reg_callback(srvr->ldc_handle, vdc_handle_cb,
852 (caddr_t)srvr);
853 if (status != 0) {
854 DMSG(vdc, 0, "[%d] LDC callback reg. failed (%d)",
855 vdc->instance, status);
856 goto init_exit;
857 }
858 srvr->state |= VDC_LDC_CB;
859 }
860
861 /*
862 * At this stage we have initialised LDC, we will now try and open
863 * the connection.
864 */
865 if (srvr->ldc_state == LDC_INIT) {
866 status = ldc_open(srvr->ldc_handle);
867 if (status != 0) {
868 DMSG(vdc, 0, "[%d] ldc_open(chan %ld) returned %d",
869 vdc->instance, srvr->ldc_id, status);
870 goto init_exit;
871 }
872 srvr->state |= VDC_LDC_OPEN;
873 }
874
875 init_exit:
876 if (status) {
877 vdc_terminate_ldc(vdc, srvr);
878 }
879
880 return (status);
881 }
882
883 static int
884 vdc_start_ldc_connection(vdc_t *vdc)
885 {
886 int status = 0;
887
888 ASSERT(vdc != NULL);
889
890 ASSERT(MUTEX_HELD(&vdc->lock));
891
892 status = vdc_do_ldc_up(vdc);
893
894 DMSG(vdc, 0, "[%d] Finished bringing up LDC\n", vdc->instance);
895
896 return (status);
897 }
898
899 static int
900 vdc_stop_ldc_connection(vdc_t *vdcp)
901 {
902 int status;
903
904 ASSERT(vdcp != NULL);
905
906 ASSERT(MUTEX_HELD(&vdcp->lock));
907
908 DMSG(vdcp, 0, ": Resetting connection to vDisk server : state %d\n",
909 vdcp->state);
910
911 status = ldc_down(vdcp->curr_server->ldc_handle);
912 DMSG(vdcp, 0, "ldc_down() = %d\n", status);
913
914 vdcp->initialized &= ~VDC_HANDSHAKE;
915 DMSG(vdcp, 0, "initialized=%x\n", vdcp->initialized);
916
917 return (status);
918 }
919
920 static void
921 vdc_create_io_kstats(vdc_t *vdc)
922 {
923 if (vdc->io_stats != NULL) {
924 DMSG(vdc, 0, "[%d] I/O kstat already exists\n", vdc->instance);
925 return;
926 }
927
928 vdc->io_stats = kstat_create(VDC_DRIVER_NAME, vdc->instance, NULL,
929 "disk", KSTAT_TYPE_IO, 1, KSTAT_FLAG_PERSISTENT);
930 if (vdc->io_stats != NULL) {
931 vdc->io_stats->ks_lock = &vdc->lock;
932 kstat_install(vdc->io_stats);
933 } else {
934 cmn_err(CE_NOTE, "[%d] Failed to create kstat: I/O statistics"
935 " will not be gathered", vdc->instance);
936 }
937 }
938
939 static void
940 vdc_create_err_kstats(vdc_t *vdc)
941 {
942 vd_err_stats_t *stp;
943 char kstatmodule_err[KSTAT_STRLEN];
944 char kstatname[KSTAT_STRLEN];
945 int ndata = (sizeof (vd_err_stats_t) / sizeof (kstat_named_t));
946 int instance = vdc->instance;
947
948 if (vdc->err_stats != NULL) {
949 DMSG(vdc, 0, "[%d] ERR kstat already exists\n", vdc->instance);
950 return;
951 }
952
953 (void) snprintf(kstatmodule_err, sizeof (kstatmodule_err),
954 "%serr", VDC_DRIVER_NAME);
955 (void) snprintf(kstatname, sizeof (kstatname),
956 "%s%d,err", VDC_DRIVER_NAME, instance);
957
958 vdc->err_stats = kstat_create(kstatmodule_err, instance, kstatname,
959 "device_error", KSTAT_TYPE_NAMED, ndata, KSTAT_FLAG_PERSISTENT);
960
961 if (vdc->err_stats == NULL) {
962 cmn_err(CE_NOTE, "[%d] Failed to create kstat: Error statistics"
963 " will not be gathered", instance);
964 return;
965 }
966
967 stp = (vd_err_stats_t *)vdc->err_stats->ks_data;
968 kstat_named_init(&stp->vd_softerrs, "Soft Errors",
969 KSTAT_DATA_UINT32);
970 kstat_named_init(&stp->vd_transerrs, "Transport Errors",
971 KSTAT_DATA_UINT32);
972 kstat_named_init(&stp->vd_protoerrs, "Protocol Errors",
973 KSTAT_DATA_UINT32);
974 kstat_named_init(&stp->vd_vid, "Vendor",
975 KSTAT_DATA_CHAR);
976 kstat_named_init(&stp->vd_pid, "Product",
977 KSTAT_DATA_CHAR);
978 kstat_named_init(&stp->vd_capacity, "Size",
979 KSTAT_DATA_ULONGLONG);
980
981 vdc->err_stats->ks_update = nulldev;
982
983 kstat_install(vdc->err_stats);
984 }
985
986 static void
987 vdc_set_err_kstats(vdc_t *vdc)
988 {
989 vd_err_stats_t *stp;
990
991 if (vdc->err_stats == NULL)
992 return;
993
994 mutex_enter(&vdc->lock);
995
996 stp = (vd_err_stats_t *)vdc->err_stats->ks_data;
997 ASSERT(stp != NULL);
998
999 stp->vd_capacity.value.ui64 = vdc->vdisk_size * vdc->vdisk_bsize;
1000 (void) strcpy(stp->vd_vid.value.c, "SUN");
1001 (void) strcpy(stp->vd_pid.value.c, "VDSK");
1002
1003 mutex_exit(&vdc->lock);
1004 }
1005
1006 static int
1007 vdc_create_device_nodes_efi(vdc_t *vdc)
1008 {
1009 ddi_remove_minor_node(vdc->dip, "h");
1010 ddi_remove_minor_node(vdc->dip, "h,raw");
1011
1012 if (ddi_create_minor_node(vdc->dip, "wd", S_IFBLK,
1013 VD_MAKE_DEV(vdc->instance, VD_EFI_WD_SLICE),
1014 DDI_NT_BLOCK, 0) != DDI_SUCCESS) {
1015 cmn_err(CE_NOTE, "[%d] Couldn't add block node 'wd'",
1016 vdc->instance);
1017 return (EIO);
1018 }
1019
1020 /* if any device node is created we set this flag */
1021 vdc->initialized |= VDC_MINOR;
1022
1023 if (ddi_create_minor_node(vdc->dip, "wd,raw", S_IFCHR,
1024 VD_MAKE_DEV(vdc->instance, VD_EFI_WD_SLICE),
1025 DDI_NT_BLOCK, 0) != DDI_SUCCESS) {
1026 cmn_err(CE_NOTE, "[%d] Couldn't add block node 'wd,raw'",
1027 vdc->instance);
1028 return (EIO);
1029 }
1030
1031 return (0);
1032 }
1033
1034 static int
1035 vdc_create_device_nodes_vtoc(vdc_t *vdc)
1036 {
1037 ddi_remove_minor_node(vdc->dip, "wd");
1038 ddi_remove_minor_node(vdc->dip, "wd,raw");
1039
1040 if (ddi_create_minor_node(vdc->dip, "h", S_IFBLK,
1041 VD_MAKE_DEV(vdc->instance, VD_EFI_WD_SLICE),
1042 DDI_NT_BLOCK, 0) != DDI_SUCCESS) {
1043 cmn_err(CE_NOTE, "[%d] Couldn't add block node 'h'",
1044 vdc->instance);
1045 return (EIO);
1046 }
1047
1048 /* if any device node is created we set this flag */
1049 vdc->initialized |= VDC_MINOR;
1050
1051 if (ddi_create_minor_node(vdc->dip, "h,raw", S_IFCHR,
1052 VD_MAKE_DEV(vdc->instance, VD_EFI_WD_SLICE),
1053 DDI_NT_BLOCK, 0) != DDI_SUCCESS) {
1054 cmn_err(CE_NOTE, "[%d] Couldn't add block node 'h,raw'",
1055 vdc->instance);
1056 return (EIO);
1057 }
1058
1059 return (0);
1060 }
1061
1062 /*
1063 * Function:
1064 * vdc_create_device_nodes
1065 *
1066 * Description:
1067 * This function creates the block and character device nodes under
1068 * /devices. It is called as part of the attach(9E) of the instance
1069 * during the handshake with vds after vds has sent the attributes
1070 * to vdc.
1071 *
1072 * If the device is of type VD_DISK_TYPE_SLICE then the minor node
1073 * of 2 is used in keeping with the Solaris convention that slice 2
1074 * refers to a whole disk. Slices start at 'a'
1075 *
1076 * Parameters:
1077 * vdc - soft state pointer
1078 *
1079 * Return Values
1080 * 0 - Success
1081 * EIO - Failed to create node
1082 */
1083 static int
1084 vdc_create_device_nodes(vdc_t *vdc)
1085 {
1086 char name[sizeof ("s,raw")];
1087 dev_info_t *dip = NULL;
1088 int instance, status;
1089 int num_slices = 1;
1090 int i;
1091
1092 ASSERT(vdc != NULL);
1093
1094 instance = vdc->instance;
1095 dip = vdc->dip;
1096
1097 switch (vdc->vdisk_type) {
1098 case VD_DISK_TYPE_DISK:
1099 case VD_DISK_TYPE_UNK:
1100 num_slices = V_NUMPAR;
1101 break;
1102 case VD_DISK_TYPE_SLICE:
1103 num_slices = 1;
1104 break;
1105 default:
1106 ASSERT(0);
1107 }
1108
1109 /*
1110 * Minor nodes are different for EFI disks: EFI disks do not have
1111 * a minor node 'g' for the minor number corresponding to slice
1112 * VD_EFI_WD_SLICE (slice 7) instead they have a minor node 'wd'
1113 * representing the whole disk.
1114 */
1115 for (i = 0; i < num_slices; i++) {
1116
1117 if (i == VD_EFI_WD_SLICE) {
1118 if (vdc->vdisk_label == VD_DISK_LABEL_EFI)
1119 status = vdc_create_device_nodes_efi(vdc);
1120 else
1121 status = vdc_create_device_nodes_vtoc(vdc);
1122 if (status != 0)
1123 return (status);
1124 continue;
1125 }
1126
1127 (void) snprintf(name, sizeof (name), "%c", 'a' + i);
1128 if (ddi_create_minor_node(dip, name, S_IFBLK,
1129 VD_MAKE_DEV(instance, i), DDI_NT_BLOCK, 0) != DDI_SUCCESS) {
1130 cmn_err(CE_NOTE, "[%d] Couldn't add block node '%s'",
1131 instance, name);
1132 return (EIO);
1133 }
1134
1135 /* if any device node is created we set this flag */
1136 vdc->initialized |= VDC_MINOR;
1137
1138 (void) snprintf(name, sizeof (name), "%c%s", 'a' + i, ",raw");
1139
1140 if (ddi_create_minor_node(dip, name, S_IFCHR,
1141 VD_MAKE_DEV(instance, i), DDI_NT_BLOCK, 0) != DDI_SUCCESS) {
1142 cmn_err(CE_NOTE, "[%d] Couldn't add raw node '%s'",
1143 instance, name);
1144 return (EIO);
1145 }
1146 }
1147
1148 return (0);
1149 }
1150
1151 /*
1152 * Driver prop_op(9e) entry point function. Return the number of blocks for
1153 * the partition in question or forward the request to the property facilities.
1154 */
1155 static int
1156 vdc_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags,
1157 char *name, caddr_t valuep, int *lengthp)
1158 {
1159 int instance = ddi_get_instance(dip);
1160 vdc_t *vdc;
1161 uint64_t nblocks;
1162 uint_t blksize;
1163
1164 vdc = ddi_get_soft_state(vdc_state, instance);
1165
1166 if (dev == DDI_DEV_T_ANY || vdc == NULL) {
1167 return (ddi_prop_op(dev, dip, prop_op, mod_flags,
1168 name, valuep, lengthp));
1169 }
1170
1171 mutex_enter(&vdc->lock);
1172 (void) vdc_validate_geometry(vdc);
1173 if (vdc->vdisk_label == VD_DISK_LABEL_UNK) {
1174 mutex_exit(&vdc->lock);
1175 return (ddi_prop_op(dev, dip, prop_op, mod_flags,
1176 name, valuep, lengthp));
1177 }
1178 nblocks = vdc->slice[VDCPART(dev)].nblocks;
1179 blksize = vdc->vdisk_bsize;
1180 mutex_exit(&vdc->lock);
1181
1182 return (ddi_prop_op_nblocks_blksize(dev, dip, prop_op, mod_flags,
1183 name, valuep, lengthp, nblocks, blksize));
1184 }
1185
1186 /*
1187 * Function:
1188 * vdc_is_opened
1189 *
1190 * Description:
1191 * This function checks if any slice of a given virtual disk is
1192 * currently opened.
1193 *
1194 * Parameters:
1195 * vdc - soft state pointer
1196 *
1197 * Return Values
1198 * B_TRUE - at least one slice is opened.
1199 * B_FALSE - no slice is opened.
1200 */
1201 static boolean_t
1202 vdc_is_opened(vdc_t *vdc)
1203 {
1204 int i;
1205
1206 /* check if there's any layered open */
1207 for (i = 0; i < V_NUMPAR; i++) {
1208 if (vdc->open_lyr[i] > 0)
1209 return (B_TRUE);
1210 }
1211
1212 /* check if there is any other kind of open */
1213 for (i = 0; i < OTYPCNT; i++) {
1214 if (vdc->open[i] != 0)
1215 return (B_TRUE);
1216 }
1217
1218 return (B_FALSE);
1219 }
1220
1221 static int
1222 vdc_mark_opened(vdc_t *vdc, int slice, int flag, int otyp)
1223 {
1224 uint8_t slicemask;
1225 int i;
1226
1227 ASSERT(otyp < OTYPCNT);
1228 ASSERT(slice < V_NUMPAR);
1229 ASSERT(MUTEX_HELD(&vdc->lock));
1230
1231 slicemask = 1 << slice;
1232
1233 /*
1234 * If we have a single-slice disk which was unavailable during the
1235 * attach then a device was created for each 8 slices. Now that
1236 * the type is known, we prevent opening any slice other than 0
1237 * even if a device still exists.
1238 */
1239 if (vdc->vdisk_type == VD_DISK_TYPE_SLICE && slice != 0)
1240 return (EIO);
1241
1242 /* check if slice is already exclusively opened */
1243 if (vdc->open_excl & slicemask)
1244 return (EBUSY);
1245
1246 /* if open exclusive, check if slice is already opened */
1247 if (flag & FEXCL) {
1248 if (vdc->open_lyr[slice] > 0)
1249 return (EBUSY);
1250 for (i = 0; i < OTYPCNT; i++) {
1251 if (vdc->open[i] & slicemask)
1252 return (EBUSY);
1253 }
1254 vdc->open_excl |= slicemask;
1255 }
1256
1257 /* mark slice as opened */
1258 if (otyp == OTYP_LYR) {
1259 vdc->open_lyr[slice]++;
1260 } else {
1261 vdc->open[otyp] |= slicemask;
1262 }
1263
1264 return (0);
1265 }
1266
1267 static void
1268 vdc_mark_closed(vdc_t *vdc, int slice, int flag, int otyp)
1269 {
1270 uint8_t slicemask;
1271
1272 ASSERT(otyp < OTYPCNT);
1273 ASSERT(slice < V_NUMPAR);
1274 ASSERT(MUTEX_HELD(&vdc->lock));
1275
1276 slicemask = 1 << slice;
1277
1278 if (otyp == OTYP_LYR) {
1279 ASSERT(vdc->open_lyr[slice] > 0);
1280 vdc->open_lyr[slice]--;
1281 } else {
1282 vdc->open[otyp] &= ~slicemask;
1283 }
1284
1285 if (flag & FEXCL)
1286 vdc->open_excl &= ~slicemask;
1287 }
1288
1289 static int
1290 vdc_open(dev_t *dev, int flag, int otyp, cred_t *cred)
1291 {
1292 _NOTE(ARGUNUSED(cred))
1293
1294 int instance, nodelay;
1295 int slice, status = 0;
1296 vdc_t *vdc;
1297
1298 ASSERT(dev != NULL);
1299 instance = VDCUNIT(*dev);
1300
1301 if (otyp >= OTYPCNT)
1302 return (EINVAL);
1303
1304 if ((vdc = ddi_get_soft_state(vdc_state, instance)) == NULL) {
1305 cmn_err(CE_NOTE, "[%d] Couldn't get state structure", instance);
1306 return (ENXIO);
1307 }
1308
1309 DMSG(vdc, 0, "minor = %d flag = %x, otyp = %x\n",
1310 getminor(*dev), flag, otyp);
1311
1312 slice = VDCPART(*dev);
1313
1314 nodelay = flag & (FNDELAY | FNONBLOCK);
1315
1316 if ((flag & FWRITE) && (!nodelay) &&
1317 !(VD_OP_SUPPORTED(vdc->operations, VD_OP_BWRITE))) {
1318 return (EROFS);
1319 }
1320
1321 mutex_enter(&vdc->lock);
1322
1323 status = vdc_mark_opened(vdc, slice, flag, otyp);
1324
1325 if (status != 0) {
1326 mutex_exit(&vdc->lock);
1327 return (status);
1328 }
1329
1330 /*
1331 * If the disk type is unknown then we have to wait for the
1332 * handshake to complete because we don't know if the slice
1333 * device we are opening effectively exists.
1334 */
1335 if (vdc->vdisk_type != VD_DISK_TYPE_UNK && nodelay) {
1336
1337 /* don't resubmit a validate request if there's already one */
1338 if (vdc->validate_pending > 0) {
1339 mutex_exit(&vdc->lock);
1340 return (0);
1341 }
1342
1343 /* call vdc_validate() asynchronously to avoid blocking */
1344 if (taskq_dispatch(system_taskq, vdc_validate_task,
1345 (void *)vdc, TQ_NOSLEEP) == NULL) {
1346 vdc_mark_closed(vdc, slice, flag, otyp);
1347 mutex_exit(&vdc->lock);
1348 return (ENXIO);
1349 }
1350
1351 vdc->validate_pending++;
1352 mutex_exit(&vdc->lock);
1353 return (0);
1354 }
1355
1356 mutex_exit(&vdc->lock);
1357
1358 vdc_validate(vdc);
1359
1360 mutex_enter(&vdc->lock);
1361
1362 if (vdc->vdisk_type == VD_DISK_TYPE_UNK ||
1363 (vdc->vdisk_type == VD_DISK_TYPE_SLICE && slice != 0) ||
1364 (!nodelay && (vdc->vdisk_label == VD_DISK_LABEL_UNK ||
1365 vdc->slice[slice].nblocks == 0))) {
1366 vdc_mark_closed(vdc, slice, flag, otyp);
1367 status = EIO;
1368 }
1369
1370 mutex_exit(&vdc->lock);
1371
1372 return (status);
1373 }
1374
1375 static int
1376 vdc_close(dev_t dev, int flag, int otyp, cred_t *cred)
1377 {
1378 _NOTE(ARGUNUSED(cred))
1379
1380 int instance;
1381 int slice;
1382 int rv, rval;
1383 vdc_t *vdc;
1384
1385 instance = VDCUNIT(dev);
1386
1387 if (otyp >= OTYPCNT)
1388 return (EINVAL);
1389
1390 if ((vdc = ddi_get_soft_state(vdc_state, instance)) == NULL) {
1391 cmn_err(CE_NOTE, "[%d] Couldn't get state structure", instance);
1392 return (ENXIO);
1393 }
1394
1395 DMSG(vdc, 0, "[%d] flag = %x, otyp = %x\n", instance, flag, otyp);
1396
1397 slice = VDCPART(dev);
1398
1399 /*
1400 * Attempt to flush the W$ on a close operation. If this is
1401 * not a supported IOCTL command or the backing device is read-only
1402 * do not fail the close operation.
1403 */
1404 rv = vd_process_ioctl(dev, DKIOCFLUSHWRITECACHE, NULL, FKIOCTL, &rval);
1405
1406 if (rv != 0 && rv != ENOTSUP && rv != ENOTTY && rv != EROFS) {
1407 DMSG(vdc, 0, "[%d] flush failed with error %d on close\n",
1408 instance, rv);
1409 return (EIO);
1410 }
1411
1412 mutex_enter(&vdc->lock);
1413 vdc_mark_closed(vdc, slice, flag, otyp);
1414 mutex_exit(&vdc->lock);
1415
1416 return (0);
1417 }
1418
1419 static int
1420 vdc_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, int *rvalp)
1421 {
1422 _NOTE(ARGUNUSED(credp))
1423
1424 return (vd_process_ioctl(dev, cmd, (caddr_t)arg, mode, rvalp));
1425 }
1426
1427 static int
1428 vdc_print(dev_t dev, char *str)
1429 {
1430 cmn_err(CE_NOTE, "vdc%d: %s", VDCUNIT(dev), str);
1431 return (0);
1432 }
1433
1434 static int
1435 vdc_dump(dev_t dev, caddr_t addr, daddr_t blkno, int nblk)
1436 {
1437 int rv, flags;
1438 size_t nbytes = nblk * DEV_BSIZE;
1439 int instance = VDCUNIT(dev);
1440 vdc_t *vdc = NULL;
1441 diskaddr_t vio_blkno;
1442
1443 if ((vdc = ddi_get_soft_state(vdc_state, instance)) == NULL) {
1444 cmn_err(CE_NOTE, "[%d] Couldn't get state structure", instance);
1445 return (ENXIO);
1446 }
1447
1448 DMSG(vdc, 2, "[%d] dump %ld bytes at block 0x%lx : addr=0x%p\n",
1449 instance, nbytes, blkno, (void *)addr);
1450
1451 /* convert logical block to vio block */
1452 if ((blkno & vdc->vio_bmask) != 0) {
1453 DMSG(vdc, 0, "Misaligned block number (%lu)\n", blkno);
1454 return (EINVAL);
1455 }
1456 vio_blkno = blkno >> vdc->vio_bshift;
1457
1458 /*
1459 * If we are panicking, we need the state to be "running" so that we
1460 * can submit I/Os, but we don't want to check for any backend error.
1461 */
1462 flags = (ddi_in_panic())? VDC_OP_STATE_RUNNING : VDC_OP_NORMAL;
1463
1464 rv = vdc_do_op(vdc, VD_OP_BWRITE, addr, nbytes, VDCPART(dev),
1465 vio_blkno, NULL, VIO_write_dir, flags);
1466
1467 if (rv) {
1468 DMSG(vdc, 0, "Failed to do a disk dump (err=%d)\n", rv);
1469 return (rv);
1470 }
1471
1472 DMSG(vdc, 0, "[%d] End\n", instance);
1473
1474 return (0);
1475 }
1476
1477 /* -------------------------------------------------------------------------- */
1478
1479 /*
1480 * Disk access routines
1481 *
1482 */
1483
1484 /*
1485 * vdc_strategy()
1486 *
1487 * Return Value:
1488 * 0: As per strategy(9E), the strategy() function must return 0
1489 * [ bioerror(9f) sets b_flags to the proper error code ]
1490 */
1491 static int
1492 vdc_strategy(struct buf *buf)
1493 {
1494 diskaddr_t vio_blkno;
1495 vdc_t *vdc = NULL;
1496 int instance = VDCUNIT(buf->b_edev);
1497 int op = (buf->b_flags & B_READ) ? VD_OP_BREAD : VD_OP_BWRITE;
1498 int slice;
1499
1500 if ((vdc = ddi_get_soft_state(vdc_state, instance)) == NULL) {
1501 cmn_err(CE_NOTE, "[%d] Couldn't get state structure", instance);
1502 bioerror(buf, ENXIO);
1503 biodone(buf);
1504 return (0);
1505 }
1506
1507 DMSG(vdc, 2, "[%d] %s %ld bytes at block %llx : b_addr=0x%p\n",
1508 instance, (buf->b_flags & B_READ) ? "Read" : "Write",
1509 buf->b_bcount, buf->b_lblkno, (void *)buf->b_un.b_addr);
1510
1511 bp_mapin(buf);
1512
1513 if ((long)buf->b_private == VD_SLICE_NONE) {
1514 /* I/O using an absolute disk offset */
1515 slice = VD_SLICE_NONE;
1516 } else {
1517 slice = VDCPART(buf->b_edev);
1518 }
1519
1520 /*
1521 * In the buf structure, b_lblkno represents a logical block number
1522 * using a block size of 512 bytes. For the VIO request, this block
1523 * number has to be converted to be represented with the block size
1524 * used by the VIO protocol.
1525 */
1526 if ((buf->b_lblkno & vdc->vio_bmask) != 0) {
1527 bioerror(buf, EINVAL);
1528 biodone(buf);
1529 return (0);
1530 }
1531 vio_blkno = buf->b_lblkno >> vdc->vio_bshift;
1532
1533 /* submit the I/O, any error will be reported in the buf structure */
1534 (void) vdc_do_op(vdc, op, (caddr_t)buf->b_un.b_addr,
1535 buf->b_bcount, slice, vio_blkno,
1536 buf, (op == VD_OP_BREAD) ? VIO_read_dir : VIO_write_dir,
1537 VDC_OP_NORMAL);
1538
1539 return (0);
1540 }
1541
1542 /*
1543 * Function:
1544 * vdc_min
1545 *
1546 * Description:
1547 * Routine to limit the size of a data transfer. Used in
1548 * conjunction with physio(9F).
1549 *
1550 * Arguments:
1551 * bp - pointer to the indicated buf(9S) struct.
1552 *
1553 */
1554 static void
1555 vdc_min(struct buf *bufp)
1556 {
1557 vdc_t *vdc = NULL;
1558 int instance = VDCUNIT(bufp->b_edev);
1559
1560 vdc = ddi_get_soft_state(vdc_state, instance);
1561 VERIFY(vdc != NULL);
1562
1563 if (bufp->b_bcount > (vdc->max_xfer_sz * vdc->vdisk_bsize)) {
1564 bufp->b_bcount = vdc->max_xfer_sz * vdc->vdisk_bsize;
1565 }
1566 }
1567
1568 static int
1569 vdc_read(dev_t dev, struct uio *uio, cred_t *cred)
1570 {
1571 _NOTE(ARGUNUSED(cred))
1572
1573 DMSGX(1, "[%d] Entered", VDCUNIT(dev));
1574 return (physio(vdc_strategy, NULL, dev, B_READ, vdc_min, uio));
1575 }
1576
1577 static int
1578 vdc_write(dev_t dev, struct uio *uio, cred_t *cred)
1579 {
1580 _NOTE(ARGUNUSED(cred))
1581
1582 DMSGX(1, "[%d] Entered", VDCUNIT(dev));
1583 return (physio(vdc_strategy, NULL, dev, B_WRITE, vdc_min, uio));
1584 }
1585
1586 static int
1587 vdc_aread(dev_t dev, struct aio_req *aio, cred_t *cred)
1588 {
1589 _NOTE(ARGUNUSED(cred))
1590
1591 DMSGX(1, "[%d] Entered", VDCUNIT(dev));
1592 return (aphysio(vdc_strategy, anocancel, dev, B_READ, vdc_min, aio));
1593 }
1594
1595 static int
1596 vdc_awrite(dev_t dev, struct aio_req *aio, cred_t *cred)
1597 {
1598 _NOTE(ARGUNUSED(cred))
1599
1600 DMSGX(1, "[%d] Entered", VDCUNIT(dev));
1601 return (aphysio(vdc_strategy, anocancel, dev, B_WRITE, vdc_min, aio));
1602 }
1603
1604
1605 /* -------------------------------------------------------------------------- */
1606
1607 /*
1608 * Handshake support
1609 */
1610
1611
1612 /*
1613 * Function:
1614 * vdc_init_ver_negotiation()
1615 *
1616 * Description:
1617 *
1618 * Arguments:
1619 * vdc - soft state pointer for this instance of the device driver.
1620 *
1621 * Return Code:
1622 * 0 - Success
1623 */
1624 static int
1625 vdc_init_ver_negotiation(vdc_t *vdc, vio_ver_t ver)
1626 {
1627 vio_ver_msg_t pkt;
1628 size_t msglen = sizeof (pkt);
1629 int status = -1;
1630
1631 ASSERT(vdc != NULL);
1632 ASSERT(mutex_owned(&vdc->lock));
1633
1634 DMSG(vdc, 0, "[%d] Entered.\n", vdc->instance);
1635
1636 /*
1637 * set the Session ID to a unique value
1638 * (the lower 32 bits of the clock tick)
1639 */
1640 vdc->session_id = ((uint32_t)gettick() & 0xffffffff);
1641 DMSG(vdc, 0, "[%d] Set SID to 0x%lx\n", vdc->instance, vdc->session_id);
1642
1643 pkt.tag.vio_msgtype = VIO_TYPE_CTRL;
1644 pkt.tag.vio_subtype = VIO_SUBTYPE_INFO;
1645 pkt.tag.vio_subtype_env = VIO_VER_INFO;
1646 pkt.tag.vio_sid = vdc->session_id;
1647 pkt.dev_class = VDEV_DISK;
1648 pkt.ver_major = ver.major;
1649 pkt.ver_minor = ver.minor;
1650
1651 status = vdc_send(vdc, (caddr_t)&pkt, &msglen);
1652 DMSG(vdc, 0, "[%d] Ver info sent (status = %d)\n",
1653 vdc->instance, status);
1654 if ((status != 0) || (msglen != sizeof (vio_ver_msg_t))) {
1655 DMSG(vdc, 0, "[%d] Failed to send Ver negotiation info: "
1656 "id(%lx) rv(%d) size(%ld)", vdc->instance,
1657 vdc->curr_server->ldc_handle, status, msglen);
1658 if (msglen != sizeof (vio_ver_msg_t))
1659 status = ENOMSG;
1660 }
1661
1662 return (status);
1663 }
1664
1665 /*
1666 * Function:
1667 * vdc_ver_negotiation()
1668 *
1669 * Description:
1670 *
1671 * Arguments:
1672 * vdcp - soft state pointer for this instance of the device driver.
1673 *
1674 * Return Code:
1675 * 0 - Success
1676 */
1677 static int
1678 vdc_ver_negotiation(vdc_t *vdcp)
1679 {
1680 vio_msg_t vio_msg;
1681 int status;
1682
1683 if (status = vdc_init_ver_negotiation(vdcp, vdc_version[0]))
1684 return (status);
1685
1686 /* release lock and wait for response */
1687 mutex_exit(&vdcp->lock);
1688 status = vdc_wait_for_response(vdcp, &vio_msg);
1689 mutex_enter(&vdcp->lock);
1690 if (status) {
1691 DMSG(vdcp, 0,
1692 "[%d] Failed waiting for Ver negotiation response, rv(%d)",
1693 vdcp->instance, status);
1694 return (status);
1695 }
1696
1697 /* check type and sub_type ... */
1698 if (vio_msg.tag.vio_msgtype != VIO_TYPE_CTRL ||
1699 vio_msg.tag.vio_subtype == VIO_SUBTYPE_INFO) {
1700 DMSG(vdcp, 0, "[%d] Invalid ver negotiation response\n",
1701 vdcp->instance);
1702 return (EPROTO);
1703 }
1704
1705 return (vdc_handle_ver_msg(vdcp, (vio_ver_msg_t *)&vio_msg));
1706 }
1707
1708 /*
1709 * Function:
1710 * vdc_init_attr_negotiation()
1711 *
1712 * Description:
1713 *
1714 * Arguments:
1715 * vdc - soft state pointer for this instance of the device driver.
1716 *
1717 * Return Code:
1718 * 0 - Success
1719 */
1720 static int
1721 vdc_init_attr_negotiation(vdc_t *vdc)
1722 {
1723 vd_attr_msg_t pkt;
1724 size_t msglen = sizeof (pkt);
1725 int status;
1726
1727 ASSERT(vdc != NULL);
1728 ASSERT(mutex_owned(&vdc->lock));
1729
1730 DMSG(vdc, 0, "[%d] entered\n", vdc->instance);
1731
1732 /* fill in tag */
1733 pkt.tag.vio_msgtype = VIO_TYPE_CTRL;
1734 pkt.tag.vio_subtype = VIO_SUBTYPE_INFO;
1735 pkt.tag.vio_subtype_env = VIO_ATTR_INFO;
1736 pkt.tag.vio_sid = vdc->session_id;
1737 /* fill in payload */
1738 pkt.max_xfer_sz = vdc->max_xfer_sz;
1739 pkt.vdisk_block_size = vdc->vdisk_bsize;
1740 pkt.xfer_mode = VIO_DRING_MODE_V1_0;
1741 pkt.operations = 0; /* server will set bits of valid operations */
1742 pkt.vdisk_type = 0; /* server will set to valid device type */
1743 pkt.vdisk_media = 0; /* server will set to valid media type */
1744 pkt.vdisk_size = 0; /* server will set to valid size */
1745
1746 status = vdc_send(vdc, (caddr_t)&pkt, &msglen);
1747 DMSG(vdc, 0, "Attr info sent (status = %d)\n", status);
1748
1749 if ((status != 0) || (msglen != sizeof (vd_attr_msg_t))) {
1750 DMSG(vdc, 0, "[%d] Failed to send Attr negotiation info: "
1751 "id(%lx) rv(%d) size(%ld)", vdc->instance,
1752 vdc->curr_server->ldc_handle, status, msglen);
1753 if (msglen != sizeof (vd_attr_msg_t))
1754 status = ENOMSG;
1755 }
1756
1757 return (status);
1758 }
1759
1760 /*
1761 * Function:
1762 * vdc_attr_negotiation()
1763 *
1764 * Description:
1765 *
1766 * Arguments:
1767 * vdc - soft state pointer for this instance of the device driver.
1768 *
1769 * Return Code:
1770 * 0 - Success
1771 */
1772 static int
1773 vdc_attr_negotiation(vdc_t *vdcp)
1774 {
1775 int status;
1776 vio_msg_t vio_msg;
1777
1778 if (status = vdc_init_attr_negotiation(vdcp))
1779 return (status);
1780
1781 /* release lock and wait for response */
1782 mutex_exit(&vdcp->lock);
1783 status = vdc_wait_for_response(vdcp, &vio_msg);
1784 mutex_enter(&vdcp->lock);
1785 if (status) {
1786 DMSG(vdcp, 0,
1787 "[%d] Failed waiting for Attr negotiation response, rv(%d)",
1788 vdcp->instance, status);
1789 return (status);
1790 }
1791
1792 /* check type and sub_type ... */
1793 if (vio_msg.tag.vio_msgtype != VIO_TYPE_CTRL ||
1794 vio_msg.tag.vio_subtype == VIO_SUBTYPE_INFO) {
1795 DMSG(vdcp, 0, "[%d] Invalid attr negotiation response\n",
1796 vdcp->instance);
1797 return (EPROTO);
1798 }
1799
1800 return (vdc_handle_attr_msg(vdcp, (vd_attr_msg_t *)&vio_msg));
1801 }
1802
1803
1804 /*
1805 * Function:
1806 * vdc_init_dring_negotiate()
1807 *
1808 * Description:
1809 *
1810 * Arguments:
1811 * vdc - soft state pointer for this instance of the device driver.
1812 *
1813 * Return Code:
1814 * 0 - Success
1815 */
1816 static int
1817 vdc_init_dring_negotiate(vdc_t *vdc)
1818 {
1819 vio_dring_reg_msg_t pkt;
1820 size_t msglen = sizeof (pkt);
1821 int status = -1;
1822 int retry;
1823 int nretries = 10;
1824
1825 ASSERT(vdc != NULL);
1826 ASSERT(mutex_owned(&vdc->lock));
1827
1828 for (retry = 0; retry < nretries; retry++) {
1829 status = vdc_init_descriptor_ring(vdc);
1830 if (status != EAGAIN)
1831 break;
1832 drv_usecwait(vdc_min_timeout_ldc);
1833 }
1834
1835 if (status != 0) {
1836 DMSG(vdc, 0, "[%d] Failed to init DRing (status = %d)\n",
1837 vdc->instance, status);
1838 return (status);
1839 }
1840
1841 DMSG(vdc, 0, "[%d] Init of descriptor ring completed (status = %d)\n",
1842 vdc->instance, status);
1843
1844 /* fill in tag */
1845 pkt.tag.vio_msgtype = VIO_TYPE_CTRL;
1846 pkt.tag.vio_subtype = VIO_SUBTYPE_INFO;
1847 pkt.tag.vio_subtype_env = VIO_DRING_REG;
1848 pkt.tag.vio_sid = vdc->session_id;
1849 /* fill in payload */
1850 pkt.dring_ident = 0;
1851 pkt.num_descriptors = vdc->dring_len;
1852 pkt.descriptor_size = vdc->dring_entry_size;
1853 pkt.options = (VIO_TX_DRING | VIO_RX_DRING);
1854 pkt.ncookies = vdc->dring_cookie_count;
1855 pkt.cookie[0] = vdc->dring_cookie[0]; /* for now just one cookie */
1856
1857 status = vdc_send(vdc, (caddr_t)&pkt, &msglen);
1858 if (status != 0) {
1859 DMSG(vdc, 0, "[%d] Failed to register DRing (err = %d)",
1860 vdc->instance, status);
1861 }
1862
1863 return (status);
1864 }
1865
1866
1867 /*
1868 * Function:
1869 * vdc_dring_negotiation()
1870 *
1871 * Description:
1872 *
1873 * Arguments:
1874 * vdc - soft state pointer for this instance of the device driver.
1875 *
1876 * Return Code:
1877 * 0 - Success
1878 */
1879 static int
1880 vdc_dring_negotiation(vdc_t *vdcp)
1881 {
1882 int status;
1883 vio_msg_t vio_msg;
1884
1885 if (status = vdc_init_dring_negotiate(vdcp))
1886 return (status);
1887
1888 /* release lock and wait for response */
1889 mutex_exit(&vdcp->lock);
1890 status = vdc_wait_for_response(vdcp, &vio_msg);
1891 mutex_enter(&vdcp->lock);
1892 if (status) {
1893 DMSG(vdcp, 0,
1894 "[%d] Failed waiting for Dring negotiation response,"
1895 " rv(%d)", vdcp->instance, status);
1896 return (status);
1897 }
1898
1899 /* check type and sub_type ... */
1900 if (vio_msg.tag.vio_msgtype != VIO_TYPE_CTRL ||
1901 vio_msg.tag.vio_subtype == VIO_SUBTYPE_INFO) {
1902 DMSG(vdcp, 0, "[%d] Invalid Dring negotiation response\n",
1903 vdcp->instance);
1904 return (EPROTO);
1905 }
1906
1907 return (vdc_handle_dring_reg_msg(vdcp,
1908 (vio_dring_reg_msg_t *)&vio_msg));
1909 }
1910
1911
1912 /*
1913 * Function:
1914 * vdc_send_rdx()
1915 *
1916 * Description:
1917 *
1918 * Arguments:
1919 * vdc - soft state pointer for this instance of the device driver.
1920 *
1921 * Return Code:
1922 * 0 - Success
1923 */
1924 static int
1925 vdc_send_rdx(vdc_t *vdcp)
1926 {
1927 vio_msg_t msg;
1928 size_t msglen = sizeof (vio_msg_t);
1929 int status;
1930
1931 /*
1932 * Send an RDX message to vds to indicate we are ready
1933 * to send data
1934 */
1935 msg.tag.vio_msgtype = VIO_TYPE_CTRL;
1936 msg.tag.vio_subtype = VIO_SUBTYPE_INFO;
1937 msg.tag.vio_subtype_env = VIO_RDX;
1938 msg.tag.vio_sid = vdcp->session_id;
1939 status = vdc_send(vdcp, (caddr_t)&msg, &msglen);
1940 if (status != 0) {
1941 DMSG(vdcp, 0, "[%d] Failed to send RDX message (%d)",
1942 vdcp->instance, status);
1943 }
1944
1945 return (status);
1946 }
1947
1948 /*
1949 * Function:
1950 * vdc_handle_rdx()
1951 *
1952 * Description:
1953 *
1954 * Arguments:
1955 * vdc - soft state pointer for this instance of the device driver.
1956 * msgp - received msg
1957 *
1958 * Return Code:
1959 * 0 - Success
1960 */
1961 static int
1962 vdc_handle_rdx(vdc_t *vdcp, vio_rdx_msg_t *msgp)
1963 {
1964 _NOTE(ARGUNUSED(vdcp))
1965 _NOTE(ARGUNUSED(msgp))
1966
1967 ASSERT(msgp->tag.vio_msgtype == VIO_TYPE_CTRL);
1968 ASSERT(msgp->tag.vio_subtype == VIO_SUBTYPE_ACK);
1969 ASSERT(msgp->tag.vio_subtype_env == VIO_RDX);
1970
1971 DMSG(vdcp, 1, "[%d] Got an RDX msg", vdcp->instance);
1972
1973 return (0);
1974 }
1975
1976 /*
1977 * Function:
1978 * vdc_rdx_exchange()
1979 *
1980 * Description:
1981 *
1982 * Arguments:
1983 * vdc - soft state pointer for this instance of the device driver.
1984 *
1985 * Return Code:
1986 * 0 - Success
1987 */
1988 static int
1989 vdc_rdx_exchange(vdc_t *vdcp)
1990 {
1991 int status;
1992 vio_msg_t vio_msg;
1993
1994 if (status = vdc_send_rdx(vdcp))
1995 return (status);
1996
1997 /* release lock and wait for response */
1998 mutex_exit(&vdcp->lock);
1999 status = vdc_wait_for_response(vdcp, &vio_msg);
2000 mutex_enter(&vdcp->lock);
2001 if (status) {
2002 DMSG(vdcp, 0, "[%d] Failed waiting for RDX response, rv(%d)",
2003 vdcp->instance, status);
2004 return (status);
2005 }
2006
2007 /* check type and sub_type ... */
2008 if (vio_msg.tag.vio_msgtype != VIO_TYPE_CTRL ||
2009 vio_msg.tag.vio_subtype != VIO_SUBTYPE_ACK) {
2010 DMSG(vdcp, 0, "[%d] Invalid RDX response\n", vdcp->instance);
2011 return (EPROTO);
2012 }
2013
2014 return (vdc_handle_rdx(vdcp, (vio_rdx_msg_t *)&vio_msg));
2015 }
2016
2017
2018 /* -------------------------------------------------------------------------- */
2019
2020 /*
2021 * LDC helper routines
2022 */
2023
2024 static int
2025 vdc_recv(vdc_t *vdc, vio_msg_t *msgp, size_t *nbytesp)
2026 {
2027 int status;
2028 uint64_t delay_time;
2029 size_t len;
2030
2031 /*
2032 * Until we get a blocking ldc read we have to retry until the entire
2033 * LDC message has arrived before ldc_read() will return that message.
2034 * If ldc_read() succeed but returns a zero length message then that
2035 * means that the LDC queue is empty and we have to wait for a
2036 * notification from the LDC callback which will set the read_state to
2037 * VDC_READ_PENDING. Note we also bail out if the channel is reset or
2038 * goes away.
2039 */
2040 delay_time = vdc_ldc_read_init_delay;
2041
2042 for (;;) {
2043
2044 len = *nbytesp;
2045 /*
2046 * vdc->curr_server is protected by vdc->lock but to avoid
2047 * contentions we don't take the lock here. We can do this
2048 * safely because vdc_recv() is only called from thread
2049 * process_msg_thread() which is also the only thread that
2050 * can change vdc->curr_server.
2051 */
2052 status = ldc_read(vdc->curr_server->ldc_handle,
2053 (caddr_t)msgp, &len);
2054
2055 if (status == EAGAIN) {
2056 delay_time *= 2;
2057 if (delay_time >= vdc_ldc_read_max_delay)
2058 delay_time = vdc_ldc_read_max_delay;
2059 delay(delay_time);
2060 continue;
2061 }
2062
2063 if (status != 0) {
2064 DMSG(vdc, 0, "ldc_read returned %d\n", status);
2065 break;
2066 }
2067
2068 if (len != 0) {
2069 *nbytesp = len;
2070 break;
2071 }
2072
2073 mutex_enter(&vdc->read_lock);
2074
2075 while (vdc->read_state != VDC_READ_PENDING) {
2076
2077 /* detect if the connection has been reset */
2078 if (vdc->read_state == VDC_READ_RESET) {
2079 mutex_exit(&vdc->read_lock);
2080 return (ECONNRESET);
2081 }
2082
2083 vdc->read_state = VDC_READ_WAITING;
2084 cv_wait(&vdc->read_cv, &vdc->read_lock);
2085 }
2086
2087 vdc->read_state = VDC_READ_IDLE;
2088 mutex_exit(&vdc->read_lock);
2089
2090 delay_time = vdc_ldc_read_init_delay;
2091 }
2092
2093 return (status);
2094 }
2095
2096
2097
2098 #ifdef DEBUG
2099 void
2100 vdc_decode_tag(vdc_t *vdcp, vio_msg_t *msg)
2101 {
2102 char *ms, *ss, *ses;
2103 switch (msg->tag.vio_msgtype) {
2104 #define Q(_s) case _s : ms = #_s; break;
2105 Q(VIO_TYPE_CTRL)
2106 Q(VIO_TYPE_DATA)
2107 Q(VIO_TYPE_ERR)
2108 #undef Q
2109 default: ms = "unknown"; break;
2110 }
2111
2112 switch (msg->tag.vio_subtype) {
2113 #define Q(_s) case _s : ss = #_s; break;
2114 Q(VIO_SUBTYPE_INFO)
2115 Q(VIO_SUBTYPE_ACK)
2116 Q(VIO_SUBTYPE_NACK)
2117 #undef Q
2118 default: ss = "unknown"; break;
2119 }
2120
2121 switch (msg->tag.vio_subtype_env) {
2122 #define Q(_s) case _s : ses = #_s; break;
2123 Q(VIO_VER_INFO)
2124 Q(VIO_ATTR_INFO)
2125 Q(VIO_DRING_REG)
2126 Q(VIO_DRING_UNREG)
2127 Q(VIO_RDX)
2128 Q(VIO_PKT_DATA)
2129 Q(VIO_DESC_DATA)
2130 Q(VIO_DRING_DATA)
2131 #undef Q
2132 default: ses = "unknown"; break;
2133 }
2134
2135 DMSG(vdcp, 3, "(%x/%x/%x) message : (%s/%s/%s)\n",
2136 msg->tag.vio_msgtype, msg->tag.vio_subtype,
2137 msg->tag.vio_subtype_env, ms, ss, ses);
2138 }
2139 #endif
2140
2141 /*
2142 * Function:
2143 * vdc_send()
2144 *
2145 * Description:
2146 * The function encapsulates the call to write a message using LDC.
2147 * If LDC indicates that the call failed due to the queue being full,
2148 * we retry the ldc_write(), otherwise we return the error returned by LDC.
2149 *
2150 * Arguments:
2151 * ldc_handle - LDC handle for the channel this instance of vdc uses
2152 * pkt - address of LDC message to be sent
2153 * msglen - the size of the message being sent. When the function
2154 * returns, this contains the number of bytes written.
2155 *
2156 * Return Code:
2157 * 0 - Success.
2158 * EINVAL - pkt or msglen were NULL
2159 * ECONNRESET - The connection was not up.
2160 * EWOULDBLOCK - LDC queue is full
2161 * xxx - other error codes returned by ldc_write
2162 */
2163 static int
2164 vdc_send(vdc_t *vdc, caddr_t pkt, size_t *msglen)
2165 {
2166 size_t size = 0;
2167 int status = 0;
2168 clock_t delay_ticks;
2169
2170 ASSERT(vdc != NULL);
2171 ASSERT(mutex_owned(&vdc->lock));
2172 ASSERT(msglen != NULL);
2173 ASSERT(*msglen != 0);
2174
2175 #ifdef DEBUG
2176 vdc_decode_tag(vdc, (vio_msg_t *)(uintptr_t)pkt);
2177 #endif
2178 /*
2179 * Wait indefinitely to send if channel
2180 * is busy, but bail out if we succeed or
2181 * if the channel closes or is reset.
2182 */
2183 delay_ticks = vdc_hz_min_ldc_delay;
2184 do {
2185 size = *msglen;
2186 status = ldc_write(vdc->curr_server->ldc_handle, pkt, &size);
2187 if (status == EWOULDBLOCK) {
2188 delay(delay_ticks);
2189 /* geometric backoff */
2190 delay_ticks *= 2;
2191 if (delay_ticks > vdc_hz_max_ldc_delay)
2192 delay_ticks = vdc_hz_max_ldc_delay;
2193 }
2194 } while (status == EWOULDBLOCK);
2195
2196 /* if LDC had serious issues --- reset vdc state */
2197 if (status == EIO || status == ECONNRESET) {
2198 /* LDC had serious issues --- reset vdc state */
2199 mutex_enter(&vdc->read_lock);
2200 if ((vdc->read_state == VDC_READ_WAITING) ||
2201 (vdc->read_state == VDC_READ_RESET))
2202 cv_signal(&vdc->read_cv);
2203 vdc->read_state = VDC_READ_RESET;
2204 mutex_exit(&vdc->read_lock);
2205
2206 /* wake up any waiters in the reset thread */
2207 if (vdc->state == VDC_STATE_INIT_WAITING) {
2208 DMSG(vdc, 0, "[%d] write reset - "
2209 "vdc is resetting ..\n", vdc->instance);
2210 vdc->state = VDC_STATE_RESETTING;
2211 cv_signal(&vdc->initwait_cv);
2212 }
2213
2214 return (ECONNRESET);
2215 }
2216
2217 /* return the last size written */
2218 *msglen = size;
2219
2220 return (status);
2221 }
2222
2223 /*
2224 * Function:
2225 * vdc_get_md_node
2226 *
2227 * Description:
2228 * Get the MD, the device node for the given disk instance. The
2229 * caller is responsible for cleaning up the reference to the
2230 * returned MD (mdpp) by calling md_fini_handle().
2231 *
2232 * Arguments:
2233 * dip - dev info pointer for this instance of the device driver.
2234 * mdpp - the returned MD.
2235 * vd_nodep - the returned device node.
2236 *
2237 * Return Code:
2238 * 0 - Success.
2239 * ENOENT - Expected node or property did not exist.
2240 * ENXIO - Unexpected error communicating with MD framework
2241 */
2242 static int
2243 vdc_get_md_node(dev_info_t *dip, md_t **mdpp, mde_cookie_t *vd_nodep)
2244 {
2245 int status = ENOENT;
2246 char *node_name = NULL;
2247 md_t *mdp = NULL;
2248 int num_nodes;
2249 int num_vdevs;
2250 mde_cookie_t rootnode;
2251 mde_cookie_t *listp = NULL;
2252 boolean_t found_inst = B_FALSE;
2253 int listsz;
2254 int idx;
2255 uint64_t md_inst;
2256 int obp_inst;
2257 int instance = ddi_get_instance(dip);
2258
2259 /*
2260 * Get the OBP instance number for comparison with the MD instance
2261 *
2262 * The "cfg-handle" property of a vdc node in an MD contains the MD's
2263 * notion of "instance", or unique identifier, for that node; OBP
2264 * stores the value of the "cfg-handle" MD property as the value of
2265 * the "reg" property on the node in the device tree it builds from
2266 * the MD and passes to Solaris. Thus, we look up the devinfo node's
2267 * "reg" property value to uniquely identify this device instance.
2268 * If the "reg" property cannot be found, the device tree state is
2269 * presumably so broken that there is no point in continuing.
2270 */
2271 if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, OBP_REG)) {
2272 cmn_err(CE_WARN, "'%s' property does not exist", OBP_REG);
2273 return (ENOENT);
2274 }
2275 obp_inst = ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
2276 OBP_REG, -1);
2277 DMSGX(1, "[%d] OBP inst=%d\n", instance, obp_inst);
2278
2279 /*
2280 * We now walk the MD nodes to find the node for this vdisk.
2281 */
2282 if ((mdp = md_get_handle()) == NULL) {
2283 cmn_err(CE_WARN, "unable to init machine description");
2284 return (ENXIO);
2285 }
2286
2287 num_nodes = md_node_count(mdp);
2288 ASSERT(num_nodes > 0);
2289
2290 listsz = num_nodes * sizeof (mde_cookie_t);
2291
2292 /* allocate memory for nodes */
2293 listp = kmem_zalloc(listsz, KM_SLEEP);
2294
2295 rootnode = md_root_node(mdp);
2296 ASSERT(rootnode != MDE_INVAL_ELEM_COOKIE);
2297
2298 /*
2299 * Search for all the virtual devices, we will then check to see which
2300 * ones are disk nodes.
2301 */
2302 num_vdevs = md_scan_dag(mdp, rootnode,
2303 md_find_name(mdp, VDC_MD_VDEV_NAME),
2304 md_find_name(mdp, "fwd"), listp);
2305
2306 if (num_vdevs <= 0) {
2307 cmn_err(CE_NOTE, "No '%s' node found", VDC_MD_VDEV_NAME);
2308 status = ENOENT;
2309 goto done;
2310 }
2311
2312 DMSGX(1, "[%d] num_vdevs=%d\n", instance, num_vdevs);
2313 for (idx = 0; idx < num_vdevs; idx++) {
2314 status = md_get_prop_str(mdp, listp[idx], "name", &node_name);
2315 if ((status != 0) || (node_name == NULL)) {
2316 cmn_err(CE_NOTE, "Unable to get name of node type '%s'"
2317 ": err %d", VDC_MD_VDEV_NAME, status);
2318 continue;
2319 }
2320
2321 DMSGX(1, "[%d] Found node '%s'\n", instance, node_name);
2322 if (strcmp(VDC_MD_DISK_NAME, node_name) == 0) {
2323 status = md_get_prop_val(mdp, listp[idx],
2324 VDC_MD_CFG_HDL, &md_inst);
2325 DMSGX(1, "[%d] vdc inst in MD=%lx\n",
2326 instance, md_inst);
2327 if ((status == 0) && (md_inst == obp_inst)) {
2328 found_inst = B_TRUE;
2329 break;
2330 }
2331 }
2332 }
2333
2334 if (!found_inst) {
2335 DMSGX(0, "Unable to find correct '%s' node", VDC_MD_DISK_NAME);
2336 status = ENOENT;
2337 goto done;
2338 }
2339 DMSGX(0, "[%d] MD inst=%lx\n", instance, md_inst);
2340
2341 *vd_nodep = listp[idx];
2342 *mdpp = mdp;
2343 done:
2344 kmem_free(listp, listsz);
2345 return (status);
2346 }
2347
2348 /*
2349 * Function:
2350 * vdc_init_ports
2351 *
2352 * Description:
2353 * Initialize all the ports for this vdisk instance.
2354 *
2355 * Arguments:
2356 * vdc - soft state pointer for this instance of the device driver.
2357 * mdp - md pointer
2358 * vd_nodep - device md node.
2359 *
2360 * Return Code:
2361 * 0 - Success.
2362 * ENOENT - Expected node or property did not exist.
2363 */
2364 static int
2365 vdc_init_ports(vdc_t *vdc, md_t *mdp, mde_cookie_t vd_nodep)
2366 {
2367 int status = 0;
2368 int idx;
2369 int num_nodes;
2370 int num_vports;
2371 int num_chans;
2372 int listsz;
2373 mde_cookie_t vd_port;
2374 mde_cookie_t *chanp = NULL;
2375 mde_cookie_t *portp = NULL;
2376 vdc_server_t *srvr;
2377 vdc_server_t *prev_srvr = NULL;
2378
2379 /*
2380 * We now walk the MD nodes to find the port nodes for this vdisk.
2381 */
2382 num_nodes = md_node_count(mdp);
2383 ASSERT(num_nodes > 0);
2384
2385 listsz = num_nodes * sizeof (mde_cookie_t);
2386
2387 /* allocate memory for nodes */
2388 portp = kmem_zalloc(listsz, KM_SLEEP);
2389 chanp = kmem_zalloc(listsz, KM_SLEEP);
2390
2391 num_vports = md_scan_dag(mdp, vd_nodep,
2392 md_find_name(mdp, VDC_MD_PORT_NAME),
2393 md_find_name(mdp, "fwd"), portp);
2394 if (num_vports == 0) {
2395 DMSGX(0, "Found no '%s' node for '%s' port\n",
2396 VDC_MD_PORT_NAME, VDC_MD_VDEV_NAME);
2397 status = ENOENT;
2398 goto done;
2399 }
2400
2401 DMSGX(1, "Found %d '%s' node(s) for '%s' port\n",
2402 num_vports, VDC_MD_PORT_NAME, VDC_MD_VDEV_NAME);
2403
2404 vdc->num_servers = 0;
2405 for (idx = 0; idx < num_vports; idx++) {
2406
2407 /* initialize this port */
2408 vd_port = portp[idx];
2409 srvr = kmem_zalloc(sizeof (vdc_server_t), KM_SLEEP);
2410 srvr->vdcp = vdc;
2411 srvr->svc_state = VDC_SERVICE_OFFLINE;
2412 srvr->log_state = VDC_SERVICE_NONE;
2413
2414 /* get port id */
2415 if (md_get_prop_val(mdp, vd_port, VDC_MD_ID, &srvr->id) != 0) {
2416 cmn_err(CE_NOTE, "vDisk port '%s' property not found",
2417 VDC_MD_ID);
2418 kmem_free(srvr, sizeof (vdc_server_t));
2419 continue;
2420 }
2421
2422 /* set the connection timeout */
2423 if (md_get_prop_val(mdp, vd_port, VDC_MD_TIMEOUT,
2424 &srvr->ctimeout) != 0) {
2425 srvr->ctimeout = 0;
2426 }
2427
2428 /* get the ldc id */
2429 num_chans = md_scan_dag(mdp, vd_port,
2430 md_find_name(mdp, VDC_MD_CHAN_NAME),
2431 md_find_name(mdp, "fwd"), chanp);
2432
2433 /* expecting at least one channel */
2434 if (num_chans <= 0) {
2435 cmn_err(CE_NOTE, "No '%s' node for '%s' port",
2436 VDC_MD_CHAN_NAME, VDC_MD_VDEV_NAME);
2437 kmem_free(srvr, sizeof (vdc_server_t));
2438 continue;
2439 } else if (num_chans != 1) {
2440 DMSGX(0, "Expected 1 '%s' node for '%s' port, "
2441 "found %d\n", VDC_MD_CHAN_NAME, VDC_MD_VDEV_NAME,
2442 num_chans);
2443 }
2444
2445 /*
2446 * We use the first channel found (index 0), irrespective of how
2447 * many are there in total.
2448 */
2449 if (md_get_prop_val(mdp, chanp[0], VDC_MD_ID,
2450 &srvr->ldc_id) != 0) {
2451 cmn_err(CE_NOTE, "Channel '%s' property not found",
2452 VDC_MD_ID);
2453 kmem_free(srvr, sizeof (vdc_server_t));
2454 continue;
2455 }
2456
2457 /*
2458 * now initialise LDC channel which will be used to
2459 * communicate with this server
2460 */
2461 if (vdc_do_ldc_init(vdc, srvr) != 0) {
2462 kmem_free(srvr, sizeof (vdc_server_t));
2463 continue;
2464 }
2465
2466 /* add server to list */
2467 if (prev_srvr)
2468 prev_srvr->next = srvr;
2469 else
2470 vdc->server_list = srvr;
2471
2472 prev_srvr = srvr;
2473
2474 /* inc numbers of servers */
2475 vdc->num_servers++;
2476 }
2477
2478 /* pick first server as current server */
2479 if (vdc->server_list != NULL) {
2480 vdc->curr_server = vdc->server_list;
2481 status = 0;
2482 } else {
2483 status = ENOENT;
2484 }
2485
2486 done:
2487 kmem_free(chanp, listsz);
2488 kmem_free(portp, listsz);
2489 return (status);
2490 }
2491
2492
2493 /*
2494 * Function:
2495 * vdc_do_ldc_up
2496 *
2497 * Description:
2498 * Bring the channel for the current server up.
2499 *
2500 * Arguments:
2501 * vdc - soft state pointer for this instance of the device driver.
2502 *
2503 * Return Code:
2504 * 0 - Success.
2505 * EINVAL - Driver is detaching / LDC error
2506 * ECONNREFUSED - Other end is not listening
2507 */
2508 static int
2509 vdc_do_ldc_up(vdc_t *vdc)
2510 {
2511 int status;
2512 ldc_status_t ldc_state;
2513
2514 ASSERT(MUTEX_HELD(&vdc->lock));
2515
2516 DMSG(vdc, 0, "[%d] Bringing up channel %lx\n",
2517 vdc->instance, vdc->curr_server->ldc_id);
2518
2519 if (vdc->lifecycle == VDC_LC_DETACHING)
2520 return (EINVAL);
2521
2522 if ((status = ldc_up(vdc->curr_server->ldc_handle)) != 0) {
2523 switch (status) {
2524 case ECONNREFUSED: /* listener not ready at other end */
2525 DMSG(vdc, 0, "[%d] ldc_up(%lx,...) return %d\n",
2526 vdc->instance, vdc->curr_server->ldc_id, status);
2527 status = 0;
2528 break;
2529 default:
2530 DMSG(vdc, 0, "[%d] Failed to bring up LDC: "
2531 "channel=%ld, err=%d", vdc->instance,
2532 vdc->curr_server->ldc_id, status);
2533 break;
2534 }
2535 }
2536
2537 if (ldc_status(vdc->curr_server->ldc_handle, &ldc_state) == 0) {
2538 vdc->curr_server->ldc_state = ldc_state;
2539 if (ldc_state == LDC_UP) {
2540 DMSG(vdc, 0, "[%d] LDC channel already up\n",
2541 vdc->instance);
2542 vdc->seq_num = 1;
2543 vdc->seq_num_reply = 0;
2544 }
2545 }
2546
2547 return (status);
2548 }
2549
2550 /*
2551 * Function:
2552 * vdc_terminate_ldc()
2553 *
2554 * Description:
2555 *
2556 * Arguments:
2557 * vdc - soft state pointer for this instance of the device driver.
2558 * srvr - vdc per-server info structure
2559 *
2560 * Return Code:
2561 * None
2562 */
2563 static void
2564 vdc_terminate_ldc(vdc_t *vdc, vdc_server_t *srvr)
2565 {
2566 int instance = ddi_get_instance(vdc->dip);
2567
2568 if (srvr->state & VDC_LDC_OPEN) {
2569 DMSG(vdc, 0, "[%d] ldc_close()\n", instance);
2570 (void) ldc_close(srvr->ldc_handle);
2571 }
2572 if (srvr->state & VDC_LDC_CB) {
2573 DMSG(vdc, 0, "[%d] ldc_unreg_callback()\n", instance);
2574 (void) ldc_unreg_callback(srvr->ldc_handle);
2575 }
2576 if (srvr->state & VDC_LDC_INIT) {
2577 DMSG(vdc, 0, "[%d] ldc_fini()\n", instance);
2578 (void) ldc_fini(srvr->ldc_handle);
2579 srvr->ldc_handle = NULL;
2580 }
2581
2582 srvr->state &= ~(VDC_LDC_INIT | VDC_LDC_CB | VDC_LDC_OPEN);
2583 }
2584
2585 /*
2586 * Function:
2587 * vdc_fini_ports()
2588 *
2589 * Description:
2590 * Finalize all ports by closing the channel associated with each
2591 * port and also freeing the server structure.
2592 *
2593 * Arguments:
2594 * vdc - soft state pointer for this instance of the device driver.
2595 *
2596 * Return Code:
2597 * None
2598 */
2599 static void
2600 vdc_fini_ports(vdc_t *vdc)
2601 {
2602 int instance = ddi_get_instance(vdc->dip);
2603 vdc_server_t *srvr, *prev_srvr;
2604
2605 ASSERT(vdc != NULL);
2606 ASSERT(mutex_owned(&vdc->lock));
2607
2608 DMSG(vdc, 0, "[%d] initialized=%x\n", instance, vdc->initialized);
2609
2610 srvr = vdc->server_list;
2611
2612 while (srvr) {
2613
2614 vdc_terminate_ldc(vdc, srvr);
2615
2616 /* next server */
2617 prev_srvr = srvr;
2618 srvr = srvr->next;
2619
2620 /* free server */
2621 kmem_free(prev_srvr, sizeof (vdc_server_t));
2622 }
2623
2624 vdc->server_list = NULL;
2625 vdc->num_servers = 0;
2626 }
2627
2628 /* -------------------------------------------------------------------------- */
2629
2630 /*
2631 * Descriptor Ring helper routines
2632 */
2633
2634 /*
2635 * Function:
2636 * vdc_init_descriptor_ring()
2637 *
2638 * Description:
2639 *
2640 * Arguments:
2641 * vdc - soft state pointer for this instance of the device driver.
2642 *
2643 * Return Code:
2644 * 0 - Success
2645 */
2646 static int
2647 vdc_init_descriptor_ring(vdc_t *vdc)
2648 {
2649 vd_dring_entry_t *dep = NULL; /* DRing Entry pointer */
2650 int status = 0;
2651 int i;
2652
2653 DMSG(vdc, 0, "[%d] initialized=%x\n", vdc->instance, vdc->initialized);
2654
2655 ASSERT(vdc != NULL);
2656 ASSERT(mutex_owned(&vdc->lock));
2657
2658 /* ensure we have enough room to store max sized block */
2659 ASSERT(maxphys <= VD_MAX_BLOCK_SIZE);
2660
2661 if ((vdc->initialized & VDC_DRING_INIT) == 0) {
2662 DMSG(vdc, 0, "[%d] ldc_mem_dring_create\n", vdc->instance);
2663 /*
2664 * Calculate the maximum block size we can transmit using one
2665 * Descriptor Ring entry from the attributes returned by the
2666 * vDisk server. This is subject to a minimum of 'maxphys'
2667 * as we do not have the capability to split requests over
2668 * multiple DRing entries.
2669 */
2670 if ((vdc->max_xfer_sz * vdc->vdisk_bsize) < maxphys) {
2671 DMSG(vdc, 0, "[%d] using minimum DRing size\n",
2672 vdc->instance);
2673 vdc->dring_max_cookies = maxphys / PAGESIZE;
2674 } else {
2675 vdc->dring_max_cookies =
2676 (vdc->max_xfer_sz * vdc->vdisk_bsize) / PAGESIZE;
2677 }
2678 vdc->dring_entry_size = (sizeof (vd_dring_entry_t) +
2679 (sizeof (ldc_mem_cookie_t) *
2680 (vdc->dring_max_cookies - 1)));
2681 vdc->dring_len = VD_DRING_LEN;
2682
2683 status = ldc_mem_dring_create(vdc->dring_len,
2684 vdc->dring_entry_size, &vdc->dring_hdl);
2685 if ((vdc->dring_hdl == NULL) || (status != 0)) {
2686 DMSG(vdc, 0, "[%d] Descriptor ring creation failed",
2687 vdc->instance);
2688 return (status);
2689 }
2690 vdc->initialized |= VDC_DRING_INIT;
2691 }
2692
2693 if ((vdc->initialized & VDC_DRING_BOUND) == 0) {
2694 DMSG(vdc, 0, "[%d] ldc_mem_dring_bind\n", vdc->instance);
2695 vdc->dring_cookie =
2696 kmem_zalloc(sizeof (ldc_mem_cookie_t), KM_SLEEP);
2697
2698 status = ldc_mem_dring_bind(vdc->curr_server->ldc_handle,
2699 vdc->dring_hdl,
2700 LDC_SHADOW_MAP|LDC_DIRECT_MAP, LDC_MEM_RW,
2701 &vdc->dring_cookie[0],
2702 &vdc->dring_cookie_count);
2703 if (status != 0) {
2704 DMSG(vdc, 0, "[%d] Failed to bind descriptor ring "
2705 "(%lx) to channel (%lx) status=%d\n",
2706 vdc->instance, vdc->dring_hdl,
2707 vdc->curr_server->ldc_handle, status);
2708 return (status);
2709 }
2710 ASSERT(vdc->dring_cookie_count == 1);
2711 vdc->initialized |= VDC_DRING_BOUND;
2712 }
2713
2714 status = ldc_mem_dring_info(vdc->dring_hdl, &vdc->dring_mem_info);
2715 if (status != 0) {
2716 DMSG(vdc, 0,
2717 "[%d] Failed to get info for descriptor ring (%lx)\n",
2718 vdc->instance, vdc->dring_hdl);
2719 return (status);
2720 }
2721
2722 if ((vdc->initialized & VDC_DRING_LOCAL) == 0) {
2723 DMSG(vdc, 0, "[%d] local dring\n", vdc->instance);
2724
2725 /* Allocate the local copy of this dring */
2726 vdc->local_dring =
2727 kmem_zalloc(vdc->dring_len * sizeof (vdc_local_desc_t),
2728 KM_SLEEP);
2729 vdc->initialized |= VDC_DRING_LOCAL;
2730 }
2731
2732 /*
2733 * Mark all DRing entries as free and initialize the private
2734 * descriptor's memory handles. If any entry is initialized,
2735 * we need to free it later so we set the bit in 'initialized'
2736 * at the start.
2737 */
2738 vdc->initialized |= VDC_DRING_ENTRY;
2739 for (i = 0; i < vdc->dring_len; i++) {
2740 dep = VDC_GET_DRING_ENTRY_PTR(vdc, i);
2741 dep->hdr.dstate = VIO_DESC_FREE;
2742
2743 status = ldc_mem_alloc_handle(vdc->curr_server->ldc_handle,
2744 &vdc->local_dring[i].desc_mhdl);
2745 if (status != 0) {
2746 DMSG(vdc, 0, "![%d] Failed to alloc mem handle for"
2747 " descriptor %d", vdc->instance, i);
2748 return (status);
2749 }
2750 vdc->local_dring[i].is_free = B_TRUE;
2751 vdc->local_dring[i].dep = dep;
2752 }
2753
2754 /* Initialize the starting index */
2755 vdc->dring_curr_idx = VDC_DRING_FIRST_ENTRY;
2756
2757 return (status);
2758 }
2759
2760 /*
2761 * Function:
2762 * vdc_destroy_descriptor_ring()
2763 *
2764 * Description:
2765 *
2766 * Arguments:
2767 * vdc - soft state pointer for this instance of the device driver.
2768 *
2769 * Return Code:
2770 * None
2771 */
2772 static void
2773 vdc_destroy_descriptor_ring(vdc_t *vdc)
2774 {
2775 vdc_local_desc_t *ldep = NULL; /* Local Dring Entry Pointer */
2776 ldc_mem_handle_t mhdl = NULL;
2777 ldc_mem_info_t minfo;
2778 int status = -1;
2779 int i; /* loop */
2780
2781 ASSERT(vdc != NULL);
2782 ASSERT(mutex_owned(&vdc->lock));
2783
2784 DMSG(vdc, 0, "[%d] Entered\n", vdc->instance);
2785
2786 if (vdc->initialized & VDC_DRING_ENTRY) {
2787 DMSG(vdc, 0,
2788 "[%d] Removing Local DRing entries\n", vdc->instance);
2789 for (i = 0; i < vdc->dring_len; i++) {
2790 ldep = &vdc->local_dring[i];
2791 mhdl = ldep->desc_mhdl;
2792
2793 if (mhdl == NULL)
2794 continue;
2795
2796 if ((status = ldc_mem_info(mhdl, &minfo)) != 0) {
2797 DMSG(vdc, 0,
2798 "ldc_mem_info returned an error: %d\n",
2799 status);
2800
2801 /*
2802 * This must mean that the mem handle
2803 * is not valid. Clear it out so that
2804 * no one tries to use it.
2805 */
2806 ldep->desc_mhdl = NULL;
2807 continue;
2808 }
2809
2810 if (minfo.status == LDC_BOUND) {
2811 (void) ldc_mem_unbind_handle(mhdl);
2812 }
2813
2814 (void) ldc_mem_free_handle(mhdl);
2815
2816 ldep->desc_mhdl = NULL;
2817 }
2818 vdc->initialized &= ~VDC_DRING_ENTRY;
2819 }
2820
2821 if (vdc->initialized & VDC_DRING_LOCAL) {
2822 DMSG(vdc, 0, "[%d] Freeing Local DRing\n", vdc->instance);
2823 kmem_free(vdc->local_dring,
2824 vdc->dring_len * sizeof (vdc_local_desc_t));
2825 vdc->initialized &= ~VDC_DRING_LOCAL;
2826 }
2827
2828 if (vdc->initialized & VDC_DRING_BOUND) {
2829 DMSG(vdc, 0, "[%d] Unbinding DRing\n", vdc->instance);
2830 status = ldc_mem_dring_unbind(vdc->dring_hdl);
2831 if (status == 0) {
2832 vdc->initialized &= ~VDC_DRING_BOUND;
2833 } else {
2834 DMSG(vdc, 0, "[%d] Error %d unbinding DRing %lx",
2835 vdc->instance, status, vdc->dring_hdl);
2836 }
2837 kmem_free(vdc->dring_cookie, sizeof (ldc_mem_cookie_t));
2838 }
2839
2840 if (vdc->initialized & VDC_DRING_INIT) {
2841 DMSG(vdc, 0, "[%d] Destroying DRing\n", vdc->instance);
2842 status = ldc_mem_dring_destroy(vdc->dring_hdl);
2843 if (status == 0) {
2844 vdc->dring_hdl = NULL;
2845 bzero(&vdc->dring_mem_info, sizeof (ldc_mem_info_t));
2846 vdc->initialized &= ~VDC_DRING_INIT;
2847 } else {
2848 DMSG(vdc, 0, "[%d] Error %d destroying DRing (%lx)",
2849 vdc->instance, status, vdc->dring_hdl);
2850 }
2851 }
2852 }
2853
2854 /*
2855 * Function:
2856 * vdc_map_to_shared_dring()
2857 *
2858 * Description:
2859 * Copy contents of the local descriptor to the shared
2860 * memory descriptor.
2861 *
2862 * Arguments:
2863 * vdcp - soft state pointer for this instance of the device driver.
2864 * idx - descriptor ring index
2865 *
2866 * Return Code:
2867 * None
2868 */
2869 static int
2870 vdc_map_to_shared_dring(vdc_t *vdcp, int idx)
2871 {
2872 vdc_local_desc_t *ldep;
2873 vd_dring_entry_t *dep;
2874 int rv;
2875
2876 ldep = &(vdcp->local_dring[idx]);
2877
2878 /* for now leave in the old pop_mem_hdl stuff */
2879 if (ldep->nbytes > 0) {
2880 rv = vdc_populate_mem_hdl(vdcp, ldep);
2881 if (rv) {
2882 DMSG(vdcp, 0, "[%d] Cannot populate mem handle\n",
2883 vdcp->instance);
2884 return (rv);
2885 }
2886 }
2887
2888 /*
2889 * fill in the data details into the DRing
2890 */
2891 dep = ldep->dep;
2892 ASSERT(dep != NULL);
2893
2894 dep->payload.req_id = VDC_GET_NEXT_REQ_ID(vdcp);
2895 dep->payload.operation = ldep->operation;
2896 dep->payload.addr = ldep->offset;
2897 dep->payload.nbytes = ldep->nbytes;
2898 dep->payload.status = (uint32_t)-1; /* vds will set valid value */
2899 dep->payload.slice = ldep->slice;
2900 dep->hdr.dstate = VIO_DESC_READY;
2901 dep->hdr.ack = 1; /* request an ACK for every message */
2902
2903 return (0);
2904 }
2905
2906 /*
2907 * Function:
2908 * vdc_send_request
2909 *
2910 * Description:
2911 * This routine writes the data to be transmitted to vds into the
2912 * descriptor, notifies vds that the ring has been updated and
2913 * then waits for the request to be processed.
2914 *
2915 * Arguments:
2916 * vdcp - the soft state pointer
2917 * operation - operation we want vds to perform (VD_OP_XXX)
2918 * addr - address of data buf to be read/written.
2919 * nbytes - number of bytes to read/write
2920 * slice - the disk slice this request is for
2921 * offset - relative disk offset
2922 * bufp - buf of operation
2923 * dir - direction of operation (READ/WRITE/BOTH)
2924 *
2925 * Return Codes:
2926 * 0
2927 * ENXIO
2928 */
2929 static int
2930 vdc_send_request(vdc_t *vdcp, int operation, caddr_t addr,
2931 size_t nbytes, int slice, diskaddr_t offset, buf_t *bufp,
2932 vio_desc_direction_t dir, int flags)
2933 {
2934 int rv = 0;
2935
2936 ASSERT(vdcp != NULL);
2937 ASSERT(slice == VD_SLICE_NONE || slice < V_NUMPAR);
2938
2939 mutex_enter(&vdcp->lock);
2940
2941 /*
2942 * If this is a block read/write operation we update the I/O statistics
2943 * to indicate that the request is being put on the waitq to be
2944 * serviced. Operations which are resubmitted are already in the waitq.
2945 *
2946 * We do it here (a common routine for both synchronous and strategy
2947 * calls) for performance reasons - we are already holding vdc->lock
2948 * so there is no extra locking overhead. We would have to explicitly
2949 * grab the 'lock' mutex to update the stats if we were to do this
2950 * higher up the stack in vdc_strategy() et. al.
2951 */
2952 if (((operation == VD_OP_BREAD) || (operation == VD_OP_BWRITE)) &&
2953 !(flags & VDC_OP_RESUBMIT)) {
2954 DTRACE_IO1(start, buf_t *, bufp);
2955 VD_KSTAT_WAITQ_ENTER(vdcp);
2956 }
2957
2958 /*
2959 * If the request does not expect the state to be VDC_STATE_RUNNING
2960 * then we just try to populate the descriptor ring once.
2961 */
2962 if (!(flags & VDC_OP_STATE_RUNNING)) {
2963 rv = vdc_populate_descriptor(vdcp, operation, addr,
2964 nbytes, slice, offset, bufp, dir, flags);
2965 goto done;
2966 }
2967
2968 do {
2969 while (vdcp->state != VDC_STATE_RUNNING) {
2970
2971 /* return error if detaching */
2972 if (vdcp->state == VDC_STATE_DETACH) {
2973 rv = ENXIO;
2974 goto done;
2975 }
2976
2977 /*
2978 * If we are panicking and the disk is not ready then
2979 * we can't send any request because we can't complete
2980 * the handshake now.
2981 */
2982 if (ddi_in_panic()) {
2983 rv = EIO;
2984 goto done;
2985 }
2986
2987 /*
2988 * If the state is faulted, notify that a new I/O is
2989 * being submitted to force the system to check if any
2990 * server has recovered.
2991 */
2992 if (vdcp->state == VDC_STATE_FAILED) {
2993 vdcp->io_pending = B_TRUE;
2994 cv_signal(&vdcp->io_pending_cv);
2995 }
2996
2997 cv_wait(&vdcp->running_cv, &vdcp->lock);
2998
2999 /* if service is still faulted then fail the request */
3000 if (vdcp->state == VDC_STATE_FAILED) {
3001 rv = EIO;
3002 goto done;
3003 }
3004 }
3005
3006 } while (vdc_populate_descriptor(vdcp, operation, addr,
3007 nbytes, slice, offset, bufp, dir, flags & ~VDC_OP_RESUBMIT));
3008
3009 done:
3010 /*
3011 * If this is a block read/write we update the I/O statistics kstat
3012 * to indicate that this request has been placed on the queue for
3013 * processing (i.e sent to the vDisk server) - iostat(1M) will
3014 * report the time waiting for the vDisk server under the %b column
3015 *
3016 * In the case of an error we take it off the wait queue only if
3017 * the I/O was not resubmited.
3018 */
3019 if ((operation == VD_OP_BREAD) || (operation == VD_OP_BWRITE)) {
3020 if (rv == 0) {
3021 VD_KSTAT_WAITQ_TO_RUNQ(vdcp);
3022 DTRACE_PROBE1(send, buf_t *, bufp);
3023 } else {
3024 VD_UPDATE_ERR_STATS(vdcp, vd_transerrs);
3025 if (!(flags & VDC_OP_RESUBMIT)) {
3026 VD_KSTAT_WAITQ_EXIT(vdcp);
3027 DTRACE_IO1(done, buf_t *, bufp);
3028 }
3029 }
3030 }
3031
3032 mutex_exit(&vdcp->lock);
3033
3034 return (rv);
3035 }
3036
3037
3038 /*
3039 * Function:
3040 * vdc_populate_descriptor
3041 *
3042 * Description:
3043 * This routine writes the data to be transmitted to vds into the
3044 * descriptor, notifies vds that the ring has been updated and
3045 * then waits for the request to be processed.
3046 *
3047 * Arguments:
3048 * vdcp - the soft state pointer
3049 * operation - operation we want vds to perform (VD_OP_XXX)
3050 * addr - address of data buf to be read/written.
3051 * nbytes - number of bytes to read/write
3052 * slice - the disk slice this request is for
3053 * offset - relative disk offset
3054 * bufp - buf of operation
3055 * dir - direction of operation (READ/WRITE/BOTH)
3056 *
3057 * Return Codes:
3058 * 0
3059 * EAGAIN
3060 * ECONNRESET
3061 * ENXIO
3062 */
3063 static int
3064 vdc_populate_descriptor(vdc_t *vdcp, int operation, caddr_t addr,
3065 size_t nbytes, int slice, diskaddr_t offset,
3066 buf_t *bufp, vio_desc_direction_t dir, int flags)
3067 {
3068 vdc_local_desc_t *local_dep = NULL; /* Local Dring Pointer */
3069 int idx; /* Index of DRing entry used */
3070 int next_idx;
3071 vio_dring_msg_t dmsg;
3072 size_t msglen;
3073 int rv;
3074
3075 ASSERT(MUTEX_HELD(&vdcp->lock));
3076 vdcp->threads_pending++;
3077 loop:
3078 DMSG(vdcp, 2, ": dring_curr_idx = %d\n", vdcp->dring_curr_idx);
3079
3080 if (flags & VDC_OP_DRING_RESERVED) {
3081 /* use D-Ring reserved entry */
3082 idx = VDC_DRING_FIRST_RESV;
3083 local_dep = &(vdcp->local_dring[idx]);
3084 } else {
3085 /* Get next available D-Ring entry */
3086 idx = vdcp->dring_curr_idx;
3087 local_dep = &(vdcp->local_dring[idx]);
3088
3089 if (!local_dep->is_free) {
3090 DMSG(vdcp, 2, "[%d]: dring full - waiting for space\n",
3091 vdcp->instance);
3092 cv_wait(&vdcp->dring_free_cv, &vdcp->lock);
3093 if (vdcp->state == VDC_STATE_RUNNING ||
3094 vdcp->state == VDC_STATE_HANDLE_PENDING) {
3095 goto loop;
3096 }
3097 vdcp->threads_pending--;
3098 return (ECONNRESET);
3099 }
3100
3101 next_idx = idx + 1;
3102 if (next_idx >= vdcp->dring_len)
3103 next_idx = VDC_DRING_FIRST_ENTRY;
3104 vdcp->dring_curr_idx = next_idx;
3105 }
3106
3107 ASSERT(local_dep->is_free);
3108
3109 local_dep->operation = operation;
3110 local_dep->addr = addr;
3111 local_dep->nbytes = nbytes;
3112 local_dep->slice = slice;
3113 local_dep->offset = offset;
3114 local_dep->buf = bufp;
3115 local_dep->dir = dir;
3116 local_dep->flags = flags;
3117
3118 local_dep->is_free = B_FALSE;
3119
3120 rv = vdc_map_to_shared_dring(vdcp, idx);
3121 if (rv) {
3122 if (flags & VDC_OP_DRING_RESERVED) {
3123 DMSG(vdcp, 0, "[%d]: cannot bind memory - error\n",
3124 vdcp->instance);
3125 /*
3126 * We can't wait if we are using reserved slot.
3127 * Free the descriptor and return.
3128 */
3129 local_dep->is_free = B_TRUE;
3130 vdcp->threads_pending--;
3131 return (rv);
3132 }
3133 DMSG(vdcp, 0, "[%d]: cannot bind memory - waiting ..\n",
3134 vdcp->instance);
3135 /* free the descriptor */
3136 local_dep->is_free = B_TRUE;
3137 vdcp->dring_curr_idx = idx;
3138 cv_wait(&vdcp->membind_cv, &vdcp->lock);
3139 if (vdcp->state == VDC_STATE_RUNNING ||
3140 vdcp->state == VDC_STATE_HANDLE_PENDING) {
3141 goto loop;
3142 }
3143 vdcp->threads_pending--;
3144 return (ECONNRESET);
3145 }
3146
3147 /*
3148 * Send a msg with the DRing details to vds
3149 */
3150 VIO_INIT_DRING_DATA_TAG(dmsg);
3151 VDC_INIT_DRING_DATA_MSG_IDS(dmsg, vdcp);
3152 dmsg.dring_ident = vdcp->dring_ident;
3153 dmsg.start_idx = idx;
3154 dmsg.end_idx = idx;
3155 vdcp->seq_num++;
3156
3157 DTRACE_PROBE2(populate, int, vdcp->instance,
3158 vdc_local_desc_t *, local_dep);
3159 DMSG(vdcp, 2, "ident=0x%lx, st=%u, end=%u, seq=%ld\n",
3160 vdcp->dring_ident, dmsg.start_idx, dmsg.end_idx, dmsg.seq_num);
3161
3162 /*
3163 * note we're still holding the lock here to
3164 * make sure the message goes out in order !!!...
3165 */
3166 msglen = sizeof (dmsg);
3167 rv = vdc_send(vdcp, (caddr_t)&dmsg, &msglen);
3168 switch (rv) {
3169 case ECONNRESET:
3170 /*
3171 * vdc_send initiates the reset on failure.
3172 * Since the transaction has already been put
3173 * on the local dring, it will automatically get
3174 * retried when the channel is reset. Given that,
3175 * it is ok to just return success even though the
3176 * send failed.
3177 */
3178 rv = 0;
3179 break;
3180
3181 case 0: /* EOK */
3182 DMSG(vdcp, 1, "sent via LDC: rv=%d\n", rv);
3183 break;
3184
3185 default:
3186 DMSG(vdcp, 0, "unexpected error, rv=%d\n", rv);
3187 rv = ENXIO;
3188 break;
3189 }
3190
3191 vdcp->threads_pending--;
3192 return (rv);
3193 }
3194
3195 /*
3196 * Function:
3197 * vdc_do_op
3198 *
3199 * Description:
3200 * Wrapper around vdc_submit_request(). Each request is associated with a
3201 * buf structure. If a buf structure is provided (bufp != NULL) then the
3202 * request will be submitted with that buf, and the caller can wait for
3203 * completion of the request with biowait(). If a buf structure is not
3204 * provided (bufp == NULL) then a buf structure is created and the function
3205 * waits for the completion of the request.
3206 *
3207 * If the flag VD_OP_STATE_RUNNING is set then vdc_submit_request() will
3208 * submit the request only when the vdisk is in state VD_STATE_RUNNING.
3209 * If the vdisk is not in that state then the vdc_submit_request() will
3210 * wait for that state to be reached. After the request is submitted, the
3211 * reply will be processed asynchronously by the vdc_process_msg_thread()
3212 * thread.
3213 *
3214 * If the flag VD_OP_STATE_RUNNING is not set then vdc_submit_request()
3215 * submit the request whatever the state of the vdisk is. Then vdc_do_op()
3216 * will wait for a reply message, process the reply and complete the
3217 * request.
3218 *
3219 * Arguments:
3220 * vdc - the soft state pointer
3221 * op - operation we want vds to perform (VD_OP_XXX)
3222 * addr - address of data buf to be read/written.
3223 * nbytes - number of bytes to read/write
3224 * slice - the disk slice this request is for
3225 * offset - relative disk offset
3226 * bufp - buf structure associated with the request (can be NULL).
3227 * dir - direction of operation (READ/WRITE/BOTH)
3228 * flags - flags for the request.
3229 *
3230 * Return Codes:
3231 * 0 - the request has been succesfully submitted and completed.
3232 * != 0 - the request has failed. In that case, if a buf structure
3233 * was provided (bufp != NULL) then the B_ERROR flag is set
3234 * and the b_error field of the buf structure is set to EIO.
3235 */
3236 static int
3237 vdc_do_op(vdc_t *vdc, int op, caddr_t addr, size_t nbytes, int slice,
3238 diskaddr_t offset, struct buf *bufp, vio_desc_direction_t dir, int flags)
3239 {
3240 vio_msg_t vio_msg;
3241 struct buf buf;
3242 int rv;
3243
3244 if (bufp == NULL) {
3245 /*
3246 * We use buf just as a convenient way to get a notification
3247 * that the request is completed, so we initialize buf to the
3248 * minimum we need.
3249 */
3250 bioinit(&buf);
3251 buf.b_bcount = nbytes;
3252 buf.b_flags = B_BUSY;
3253 bufp = &buf;
3254 }
3255
3256 rv = vdc_send_request(vdc, op, addr, nbytes, slice, offset, bufp,
3257 dir, flags);
3258
3259 if (rv != 0)
3260 goto done;
3261
3262 /*
3263 * If the request should be done in VDC_STATE_RUNNING state then the
3264 * reply will be received and processed by vdc_process_msg_thread()
3265 * and we just have to handle the panic case. Otherwise we have to
3266 * wait for the reply message and process it.
3267 */
3268 if (flags & VDC_OP_STATE_RUNNING) {
3269
3270 if (ddi_in_panic()) {
3271 rv = vdc_drain_response(vdc, bufp);
3272 goto done;
3273 }
3274
3275 } else {
3276 /* wait for the response message */
3277 rv = vdc_wait_for_response(vdc, &vio_msg);
3278
3279 if (rv == 0)
3280 rv = vdc_process_data_msg(vdc, &vio_msg);
3281
3282 if (rv) {
3283 /*
3284 * If this is a block read/write we update the I/O
3285 * statistics kstat to take it off the run queue.
3286 * If it is a resubmit then it needs to stay in
3287 * in the waitq, and it will be removed when the
3288 * I/O is eventually completed or cancelled.
3289 */
3290 mutex_enter(&vdc->lock);
3291 if (op == VD_OP_BREAD || op == VD_OP_BWRITE) {
3292 if (flags & VDC_OP_RESUBMIT) {
3293 VD_KSTAT_RUNQ_BACK_TO_WAITQ(vdc);
3294 } else {
3295 VD_KSTAT_RUNQ_EXIT(vdc);
3296 DTRACE_IO1(done, buf_t *, bufp);
3297 }
3298 }
3299 mutex_exit(&vdc->lock);
3300 goto done;
3301 }
3302
3303 }
3304
3305 if (bufp == &buf)
3306 rv = biowait(bufp);
3307
3308 done:
3309 if (bufp == &buf) {
3310 biofini(bufp);
3311 } else if (rv != 0) {
3312 bioerror(bufp, EIO);
3313 biodone(bufp);
3314 }
3315
3316 return (rv);
3317 }
3318
3319 /*
3320 * Function:
3321 * vdc_do_sync_op
3322 *
3323 * Description:
3324 * Wrapper around vdc_do_op that serializes requests.
3325 *
3326 * Arguments:
3327 * vdcp - the soft state pointer
3328 * operation - operation we want vds to perform (VD_OP_XXX)
3329 * addr - address of data buf to be read/written.
3330 * nbytes - number of bytes to read/write
3331 * slice - the disk slice this request is for
3332 * offset - relative disk offset
3333 * dir - direction of operation (READ/WRITE/BOTH)
3334 * rconflict - check for reservation conflict in case of failure
3335 *
3336 * rconflict should be set to B_TRUE by most callers. Callers invoking the
3337 * VD_OP_SCSICMD operation can set rconflict to B_FALSE if they check the
3338 * result of a successful operation with vdc_scsi_status().
3339 *
3340 * Return Codes:
3341 * 0
3342 * EAGAIN
3343 * EFAULT
3344 * ENXIO
3345 * EIO
3346 */
3347 static int
3348 vdc_do_sync_op(vdc_t *vdcp, int operation, caddr_t addr, size_t nbytes,
3349 int slice, diskaddr_t offset, vio_desc_direction_t dir, boolean_t rconflict)
3350 {
3351 int status;
3352 int flags = VDC_OP_NORMAL;
3353
3354 /*
3355 * Grab the lock, if blocked wait until the server
3356 * response causes us to wake up again.
3357 */
3358 mutex_enter(&vdcp->lock);
3359 vdcp->sync_op_cnt++;
3360 while (vdcp->sync_op_blocked && vdcp->state != VDC_STATE_DETACH) {
3361 if (ddi_in_panic()) {
3362 /* don't block if we are panicking */
3363 vdcp->sync_op_cnt--;
3364 mutex_exit(&vdcp->lock);
3365 return (EIO);
3366 } else {
3367 cv_wait(&vdcp->sync_blocked_cv, &vdcp->lock);
3368 }
3369 }
3370
3371 if (vdcp->state == VDC_STATE_DETACH) {
3372 cv_broadcast(&vdcp->sync_blocked_cv);
3373 vdcp->sync_op_cnt--;
3374 mutex_exit(&vdcp->lock);
3375 return (ENXIO);
3376 }
3377
3378 /* now block anyone other thread entering after us */
3379 vdcp->sync_op_blocked = B_TRUE;
3380
3381 mutex_exit(&vdcp->lock);
3382
3383 if (!rconflict)
3384 flags &= ~VDC_OP_ERRCHK_CONFLICT;
3385
3386 status = vdc_do_op(vdcp, operation, addr, nbytes, slice, offset,
3387 NULL, dir, flags);
3388
3389 mutex_enter(&vdcp->lock);
3390
3391 DMSG(vdcp, 2, ": operation returned %d\n", status);
3392
3393 if (vdcp->state == VDC_STATE_DETACH) {
3394 status = ENXIO;
3395 }
3396
3397 vdcp->sync_op_blocked = B_FALSE;
3398 vdcp->sync_op_cnt--;
3399
3400 /* signal the next waiting thread */
3401 cv_signal(&vdcp->sync_blocked_cv);
3402
3403 mutex_exit(&vdcp->lock);
3404
3405 return (status);
3406 }
3407
3408
3409 /*
3410 * Function:
3411 * vdc_drain_response()
3412 *
3413 * Description:
3414 * When a guest is panicking, the completion of requests needs to be
3415 * handled differently because interrupts are disabled and vdc
3416 * will not get messages. We have to poll for the messages instead.
3417 *
3418 * Note: since we are panicking we don't implement the io:::done
3419 * DTrace probe or update the I/O statistics kstats.
3420 *
3421 * Arguments:
3422 * vdc - soft state pointer for this instance of the device driver.
3423 * buf - if buf is NULL then we drain all responses, otherwise we
3424 * poll until we receive a ACK/NACK for the specific I/O
3425 * described by buf.
3426 *
3427 * Return Code:
3428 * 0 - Success. If we were expecting a response to a particular
3429 * request then this means that a response has been received.
3430 */
3431 static int
3432 vdc_drain_response(vdc_t *vdc, struct buf *buf)
3433 {
3434 int rv, idx, retries;
3435 size_t msglen;
3436 vdc_local_desc_t *ldep = NULL; /* Local Dring Entry Pointer */
3437 vio_dring_msg_t dmsg;
3438 struct buf *mbuf;
3439 boolean_t ack;
3440
3441 mutex_enter(&vdc->lock);
3442
3443 retries = 0;
3444 for (;;) {
3445 msglen = sizeof (dmsg);
3446 rv = ldc_read(vdc->curr_server->ldc_handle, (caddr_t)&dmsg,
3447 &msglen);
3448 if (rv) {
3449 rv = EINVAL;
3450 break;
3451 }
3452
3453 /*
3454 * if there are no packets wait and check again
3455 */
3456 if ((rv == 0) && (msglen == 0)) {
3457 if (retries++ > vdc_dump_retries) {
3458 rv = EAGAIN;
3459 break;
3460 }
3461
3462 drv_usecwait(vdc_usec_timeout_dump);
3463 continue;
3464 }
3465
3466 /*
3467 * Ignore all messages that are not ACKs/NACKs to
3468 * DRing requests.
3469 */
3470 if ((dmsg.tag.vio_msgtype != VIO_TYPE_DATA) ||
3471 (dmsg.tag.vio_subtype_env != VIO_DRING_DATA)) {
3472 DMSG(vdc, 0, "discard pkt: type=%d sub=%d env=%d\n",
3473 dmsg.tag.vio_msgtype,
3474 dmsg.tag.vio_subtype,
3475 dmsg.tag.vio_subtype_env);
3476 continue;
3477 }
3478
3479 /*
3480 * Record if the packet was ACK'ed or not. If the packet was not
3481 * ACK'ed then we will just mark the request as failed; we don't
3482 * want to reset the connection at this point.
3483 */
3484 switch (dmsg.tag.vio_subtype) {
3485 case VIO_SUBTYPE_ACK:
3486 ack = B_TRUE;
3487 break;
3488 case VIO_SUBTYPE_NACK:
3489 ack = B_FALSE;
3490 break;
3491 default:
3492 continue;
3493 }
3494
3495 idx = dmsg.start_idx;
3496 if (idx >= vdc->dring_len) {
3497 DMSG(vdc, 0, "[%d] Bogus ack data : start %d\n",
3498 vdc->instance, idx);
3499 continue;
3500 }
3501 ldep = &vdc->local_dring[idx];
3502 if (ldep->dep->hdr.dstate != VIO_DESC_DONE) {
3503 DMSG(vdc, 0, "[%d] Entry @ %d - state !DONE %d\n",
3504 vdc->instance, idx, ldep->dep->hdr.dstate);
3505 continue;
3506 }
3507
3508 mbuf = ldep->buf;
3509 ASSERT(mbuf != NULL);
3510 mbuf->b_resid = mbuf->b_bcount - ldep->dep->payload.nbytes;
3511 bioerror(mbuf, ack ? ldep->dep->payload.status : EIO);
3512 biodone(mbuf);
3513
3514 rv = vdc_depopulate_descriptor(vdc, idx);
3515 if (buf != NULL && buf == mbuf) {
3516 rv = 0;
3517 goto done;
3518 }
3519
3520 /* if this is the last descriptor - break out of loop */
3521 if ((idx + 1) % vdc->dring_len == vdc->dring_curr_idx) {
3522 /*
3523 * If we were expecting a response for a particular
3524 * request then we return with an error otherwise we
3525 * have successfully completed the drain.
3526 */
3527 rv = (buf != NULL)? ESRCH: 0;
3528 break;
3529 }
3530 }
3531
3532 done:
3533 mutex_exit(&vdc->lock);
3534 DMSG(vdc, 0, "End idx=%d\n", idx);
3535
3536 return (rv);
3537 }
3538
3539
3540 /*
3541 * Function:
3542 * vdc_depopulate_descriptor()
3543 *
3544 * Description:
3545 *
3546 * Arguments:
3547 * vdc - soft state pointer for this instance of the device driver.
3548 * idx - Index of the Descriptor Ring entry being modified
3549 *
3550 * Return Code:
3551 * 0 - Success
3552 */
3553 static int
3554 vdc_depopulate_descriptor(vdc_t *vdc, uint_t idx)
3555 {
3556 vd_dring_entry_t *dep = NULL; /* Dring Entry Pointer */
3557 vdc_local_desc_t *ldep = NULL; /* Local Dring Entry Pointer */
3558 int status = ENXIO;
3559 int rv = 0;
3560
3561 ASSERT(vdc != NULL);
3562 ASSERT(idx < vdc->dring_len);
3563 ldep = &vdc->local_dring[idx];
3564 ASSERT(ldep != NULL);
3565 ASSERT(MUTEX_HELD(&vdc->lock));
3566
3567 DTRACE_PROBE2(depopulate, int, vdc->instance, vdc_local_desc_t *, ldep);
3568 DMSG(vdc, 2, ": idx = %d\n", idx);
3569
3570 dep = ldep->dep;
3571 ASSERT(dep != NULL);
3572 ASSERT((dep->hdr.dstate == VIO_DESC_DONE) ||
3573 (dep->payload.status == ECANCELED));
3574
3575 VDC_MARK_DRING_ENTRY_FREE(vdc, idx);
3576
3577 ldep->is_free = B_TRUE;
3578 status = dep->payload.status;
3579 DMSG(vdc, 2, ": is_free = %d : status = %d\n", ldep->is_free, status);
3580
3581 /*
3582 * If no buffers were used to transfer information to the server when
3583 * populating the descriptor then no memory handles need to be unbound
3584 * and we can return now.
3585 */
3586 if (ldep->nbytes == 0) {
3587 cv_signal(&vdc->dring_free_cv);
3588 return (status);
3589 }
3590
3591 /*
3592 * If the upper layer passed in a misaligned address we copied the
3593 * data into an aligned buffer before sending it to LDC - we now
3594 * copy it back to the original buffer.
3595 */
3596 if (ldep->align_addr) {
3597 ASSERT(ldep->addr != NULL);
3598
3599 if (dep->payload.nbytes > 0)
3600 bcopy(ldep->align_addr, ldep->addr,
3601 dep->payload.nbytes);
3602 kmem_free(ldep->align_addr,
3603 sizeof (caddr_t) * P2ROUNDUP(ldep->nbytes, 8));
3604 ldep->align_addr = NULL;
3605 }
3606
3607 rv = ldc_mem_unbind_handle(ldep->desc_mhdl);
3608 if (rv != 0) {
3609 DMSG(vdc, 0, "?[%d] unbind mhdl 0x%lx @ idx %d failed (%d)",
3610 vdc->instance, ldep->desc_mhdl, idx, rv);
3611 /*
3612 * The error returned by the vDisk server is more informative
3613 * and thus has a higher priority but if it isn't set we ensure
3614 * that this function returns an error.
3615 */
3616 if (status == 0)
3617 status = EINVAL;
3618 }
3619
3620 cv_signal(&vdc->membind_cv);
3621 cv_signal(&vdc->dring_free_cv);
3622
3623 return (status);
3624 }
3625
3626 /*
3627 * Function:
3628 * vdc_populate_mem_hdl()
3629 *
3630 * Description:
3631 *
3632 * Arguments:
3633 * vdc - soft state pointer for this instance of the device driver.
3634 * idx - Index of the Descriptor Ring entry being modified
3635 * addr - virtual address being mapped in
3636 * nybtes - number of bytes in 'addr'
3637 * operation - the vDisk operation being performed (VD_OP_xxx)
3638 *
3639 * Return Code:
3640 * 0 - Success
3641 */
3642 static int
3643 vdc_populate_mem_hdl(vdc_t *vdcp, vdc_local_desc_t *ldep)
3644 {
3645 vd_dring_entry_t *dep = NULL;
3646 ldc_mem_handle_t mhdl;
3647 caddr_t vaddr;
3648 size_t nbytes;
3649 uint8_t perm = LDC_MEM_RW;
3650 uint8_t maptype;
3651 int rv = 0;
3652 int i;
3653
3654 ASSERT(vdcp != NULL);
3655
3656 dep = ldep->dep;
3657 mhdl = ldep->desc_mhdl;
3658
3659 switch (ldep->dir) {
3660 case VIO_read_dir:
3661 perm = LDC_MEM_W;
3662 break;
3663
3664 case VIO_write_dir:
3665 perm = LDC_MEM_R;
3666 break;
3667
3668 case VIO_both_dir:
3669 perm = LDC_MEM_RW;
3670 break;
3671
3672 default:
3673 ASSERT(0); /* catch bad programming in vdc */
3674 }
3675
3676 /*
3677 * LDC expects any addresses passed in to be 8-byte aligned. We need
3678 * to copy the contents of any misaligned buffers to a newly allocated
3679 * buffer and bind it instead (and copy the the contents back to the
3680 * original buffer passed in when depopulating the descriptor)
3681 */
3682 vaddr = ldep->addr;
3683 nbytes = ldep->nbytes;
3684 if (((uint64_t)vaddr & 0x7) != 0) {
3685 ASSERT(ldep->align_addr == NULL);
3686 ldep->align_addr =
3687 kmem_alloc(sizeof (caddr_t) *
3688 P2ROUNDUP(nbytes, 8), KM_SLEEP);
3689 DMSG(vdcp, 0, "[%d] Misaligned address %p reallocating "
3690 "(buf=%p nb=%ld op=%d)\n",
3691 vdcp->instance, (void *)vaddr, (void *)ldep->align_addr,
3692 nbytes, ldep->operation);
3693 if (perm != LDC_MEM_W)
3694 bcopy(vaddr, ldep->align_addr, nbytes);
3695 vaddr = ldep->align_addr;
3696 }
3697
3698 maptype = LDC_IO_MAP|LDC_SHADOW_MAP;
3699 rv = ldc_mem_bind_handle(mhdl, vaddr, P2ROUNDUP(nbytes, 8),
3700 maptype, perm, &dep->payload.cookie[0], &dep->payload.ncookies);
3701 DMSG(vdcp, 2, "[%d] bound mem handle; ncookies=%d\n",
3702 vdcp->instance, dep->payload.ncookies);
3703 if (rv != 0) {
3704 DMSG(vdcp, 0, "[%d] Failed to bind LDC memory handle "
3705 "(mhdl=%p, buf=%p, err=%d)\n",
3706 vdcp->instance, (void *)mhdl, (void *)vaddr, rv);
3707 if (ldep->align_addr) {
3708 kmem_free(ldep->align_addr,
3709 sizeof (caddr_t) * P2ROUNDUP(nbytes, 8));
3710 ldep->align_addr = NULL;
3711 }
3712 return (EAGAIN);
3713 }
3714
3715 /*
3716 * Get the other cookies (if any).
3717 */
3718 for (i = 1; i < dep->payload.ncookies; i++) {
3719 rv = ldc_mem_nextcookie(mhdl, &dep->payload.cookie[i]);
3720 if (rv != 0) {
3721 (void) ldc_mem_unbind_handle(mhdl);
3722 DMSG(vdcp, 0, "?[%d] Failed to get next cookie "
3723 "(mhdl=%lx cnum=%d), err=%d",
3724 vdcp->instance, mhdl, i, rv);
3725 if (ldep->align_addr) {
3726 kmem_free(ldep->align_addr,
3727 sizeof (caddr_t) * ldep->nbytes);
3728 ldep->align_addr = NULL;
3729 }
3730 return (EAGAIN);
3731 }
3732 }
3733
3734 return (rv);
3735 }
3736
3737 /*
3738 * Interrupt handlers for messages from LDC
3739 */
3740
3741 /*
3742 * Function:
3743 * vdc_handle_cb()
3744 *
3745 * Description:
3746 *
3747 * Arguments:
3748 * event - Type of event (LDC_EVT_xxx) that triggered the callback
3749 * arg - soft state pointer for this instance of the device driver.
3750 *
3751 * Return Code:
3752 * 0 - Success
3753 */
3754 static uint_t
3755 vdc_handle_cb(uint64_t event, caddr_t arg)
3756 {
3757 ldc_status_t ldc_state;
3758 int rv = 0;
3759 vdc_server_t *srvr = (vdc_server_t *)(void *)arg;
3760 vdc_t *vdc = srvr->vdcp;
3761
3762 ASSERT(vdc != NULL);
3763
3764 DMSG(vdc, 1, "evt=%lx seqID=%ld\n", event, vdc->seq_num);
3765
3766 /* If callback is not for the current server, ignore it */
3767 mutex_enter(&vdc->lock);
3768
3769 if (vdc->curr_server != srvr) {
3770 DMSG(vdc, 0, "[%d] Ignoring event 0x%lx for port@%ld\n",
3771 vdc->instance, event, srvr->id);
3772 mutex_exit(&vdc->lock);
3773 return (LDC_SUCCESS);
3774 }
3775
3776 /*
3777 * Depending on the type of event that triggered this callback,
3778 * we modify the handshake state or read the data.
3779 *
3780 * NOTE: not done as a switch() as event could be triggered by
3781 * a state change and a read request. Also the ordering of the
3782 * check for the event types is deliberate.
3783 */
3784 if (event & LDC_EVT_UP) {
3785 DMSG(vdc, 0, "[%d] Received LDC_EVT_UP\n", vdc->instance);
3786
3787 /* get LDC state */
3788 rv = ldc_status(srvr->ldc_handle, &ldc_state);
3789 if (rv != 0) {
3790 DMSG(vdc, 0, "[%d] Couldn't get LDC status %d",
3791 vdc->instance, rv);
3792 mutex_exit(&vdc->lock);
3793 return (LDC_SUCCESS);
3794 }
3795 if (srvr->ldc_state != LDC_UP &&
3796 ldc_state == LDC_UP) {
3797 /*
3798 * Reset the transaction sequence numbers when
3799 * LDC comes up. We then kick off the handshake
3800 * negotiation with the vDisk server.
3801 */
3802 vdc->seq_num = 1;
3803 vdc->seq_num_reply = 0;
3804 vdc->io_pending = B_TRUE;
3805 srvr->ldc_state = ldc_state;
3806 cv_signal(&vdc->initwait_cv);
3807 cv_signal(&vdc->io_pending_cv);
3808 }
3809 }
3810
3811 if (event & LDC_EVT_READ) {
3812 DMSG(vdc, 1, "[%d] Received LDC_EVT_READ\n", vdc->instance);
3813 mutex_enter(&vdc->read_lock);
3814 cv_signal(&vdc->read_cv);
3815 vdc->read_state = VDC_READ_PENDING;
3816 mutex_exit(&vdc->read_lock);
3817 mutex_exit(&vdc->lock);
3818
3819 /* that's all we have to do - no need to handle DOWN/RESET */
3820 return (LDC_SUCCESS);
3821 }
3822
3823 if (event & (LDC_EVT_RESET|LDC_EVT_DOWN)) {
3824
3825 DMSG(vdc, 0, "[%d] Received LDC RESET event\n", vdc->instance);
3826
3827 /*
3828 * Need to wake up any readers so they will
3829 * detect that a reset has occurred.
3830 */
3831 mutex_enter(&vdc->read_lock);
3832 if ((vdc->read_state == VDC_READ_WAITING) ||
3833 (vdc->read_state == VDC_READ_RESET))
3834 cv_signal(&vdc->read_cv);
3835 vdc->read_state = VDC_READ_RESET;
3836 mutex_exit(&vdc->read_lock);
3837
3838 /* wake up any threads waiting for connection to come up */
3839 if (vdc->state == VDC_STATE_INIT_WAITING) {
3840 vdc->state = VDC_STATE_RESETTING;
3841 cv_signal(&vdc->initwait_cv);
3842 } else if (vdc->state == VDC_STATE_FAILED) {
3843 vdc->io_pending = B_TRUE;
3844 cv_signal(&vdc->io_pending_cv);
3845 }
3846
3847 }
3848
3849 mutex_exit(&vdc->lock);
3850
3851 if (event & ~(LDC_EVT_UP | LDC_EVT_RESET | LDC_EVT_DOWN | LDC_EVT_READ))
3852 DMSG(vdc, 0, "![%d] Unexpected LDC event (%lx) received",
3853 vdc->instance, event);
3854
3855 return (LDC_SUCCESS);
3856 }
3857
3858 /*
3859 * Function:
3860 * vdc_wait_for_response()
3861 *
3862 * Description:
3863 * Block waiting for a response from the server. If there is
3864 * no data the thread block on the read_cv that is signalled
3865 * by the callback when an EVT_READ occurs.
3866 *
3867 * Arguments:
3868 * vdcp - soft state pointer for this instance of the device driver.
3869 *
3870 * Return Code:
3871 * 0 - Success
3872 */
3873 static int
3874 vdc_wait_for_response(vdc_t *vdcp, vio_msg_t *msgp)
3875 {
3876 size_t nbytes = sizeof (*msgp);
3877 int status;
3878
3879 ASSERT(vdcp != NULL);
3880
3881 DMSG(vdcp, 1, "[%d] Entered\n", vdcp->instance);
3882
3883 status = vdc_recv(vdcp, msgp, &nbytes);
3884 DMSG(vdcp, 3, "vdc_read() done.. status=0x%x size=0x%x\n",
3885 status, (int)nbytes);
3886 if (status) {
3887 DMSG(vdcp, 0, "?[%d] Error %d reading LDC msg\n",
3888 vdcp->instance, status);
3889 return (status);
3890 }
3891
3892 if (nbytes < sizeof (vio_msg_tag_t)) {
3893 DMSG(vdcp, 0, "?[%d] Expect %lu bytes; recv'd %lu\n",
3894 vdcp->instance, sizeof (vio_msg_tag_t), nbytes);
3895 return (ENOMSG);
3896 }
3897
3898 DMSG(vdcp, 2, "[%d] (%x/%x/%x)\n", vdcp->instance,
3899 msgp->tag.vio_msgtype,
3900 msgp->tag.vio_subtype,
3901 msgp->tag.vio_subtype_env);
3902
3903 /*
3904 * Verify the Session ID of the message
3905 *
3906 * Every message after the Version has been negotiated should
3907 * have the correct session ID set.
3908 */
3909 if ((msgp->tag.vio_sid != vdcp->session_id) &&
3910 (msgp->tag.vio_subtype_env != VIO_VER_INFO)) {
3911 DMSG(vdcp, 0, "[%d] Invalid SID: received 0x%x, "
3912 "expected 0x%lx [seq num %lx @ %d]",
3913 vdcp->instance, msgp->tag.vio_sid,
3914 vdcp->session_id,
3915 ((vio_dring_msg_t *)msgp)->seq_num,
3916 ((vio_dring_msg_t *)msgp)->start_idx);
3917 return (ENOMSG);
3918 }
3919 return (0);
3920 }
3921
3922
3923 /*
3924 * Function:
3925 * vdc_resubmit_backup_dring()
3926 *
3927 * Description:
3928 * Resubmit each descriptor in the backed up dring to
3929 * vDisk server. The Dring was backed up during connection
3930 * reset.
3931 *
3932 * Arguments:
3933 * vdcp - soft state pointer for this instance of the device driver.
3934 *
3935 * Return Code:
3936 * 0 - Success
3937 */
3938 static int
3939 vdc_resubmit_backup_dring(vdc_t *vdcp)
3940 {
3941 int processed = 0;
3942 int count;
3943 int b_idx;
3944 int rv = 0;
3945 int dring_size;
3946 vdc_local_desc_t *curr_ldep;
3947
3948 ASSERT(MUTEX_NOT_HELD(&vdcp->lock));
3949 ASSERT(vdcp->state == VDC_STATE_HANDLE_PENDING);
3950
3951 if (vdcp->local_dring_backup == NULL) {
3952 /* the pending requests have already been processed */
3953 return (0);
3954 }
3955
3956 DMSG(vdcp, 1, "restoring pending dring entries (len=%d, tail=%d)\n",
3957 vdcp->local_dring_backup_len, vdcp->local_dring_backup_tail);
3958
3959 /*
3960 * Walk the backup copy of the local descriptor ring and
3961 * resubmit all the outstanding transactions.
3962 */
3963 b_idx = vdcp->local_dring_backup_tail;
3964 for (count = 0; count < vdcp->local_dring_backup_len; count++) {
3965
3966 curr_ldep = &(vdcp->local_dring_backup[b_idx]);
3967
3968 /* only resubmit outstanding transactions */
3969 if (!curr_ldep->is_free) {
3970
3971 DMSG(vdcp, 1, "resubmitting entry idx=%x\n", b_idx);
3972
3973 rv = vdc_do_op(vdcp, curr_ldep->operation,
3974 curr_ldep->addr, curr_ldep->nbytes,
3975 curr_ldep->slice, curr_ldep->offset,
3976 curr_ldep->buf, curr_ldep->dir,
3977 (curr_ldep->flags & ~VDC_OP_STATE_RUNNING) |
3978 VDC_OP_RESUBMIT);
3979
3980 if (rv) {
3981 DMSG(vdcp, 1, "[%d] resubmit entry %d failed\n",
3982 vdcp->instance, b_idx);
3983 goto done;
3984 }
3985
3986 /*
3987 * Mark this entry as free so that we will not resubmit
3988 * this "done" request again, if we were to use the same
3989 * backup_dring again in future. This could happen when
3990 * a reset happens while processing the backup_dring.
3991 */
3992 curr_ldep->is_free = B_TRUE;
3993 processed++;
3994 }
3995
3996 /* get the next element to submit */
3997 if (++b_idx >= vdcp->local_dring_backup_len)
3998 b_idx = 0;
3999 }
4000
4001 /* all done - now clear up pending dring copy */
4002 dring_size = vdcp->local_dring_backup_len *
4003 sizeof (vdcp->local_dring_backup[0]);
4004
4005 (void) kmem_free(vdcp->local_dring_backup, dring_size);
4006
4007 vdcp->local_dring_backup = NULL;
4008
4009 done:
4010 DTRACE_PROBE2(processed, int, processed, vdc_t *, vdcp);
4011
4012 return (rv);
4013 }
4014
4015 /*
4016 * Function:
4017 * vdc_cancel_backup_dring
4018 *
4019 * Description:
4020 * Cancel each descriptor in the backed up dring to vDisk server.
4021 * The Dring was backed up during connection reset.
4022 *
4023 * Arguments:
4024 * vdcp - soft state pointer for this instance of the device driver.
4025 *
4026 * Return Code:
4027 * None
4028 */
4029 void
4030 vdc_cancel_backup_dring(vdc_t *vdcp)
4031 {
4032 vdc_local_desc_t *ldep;
4033 struct buf *bufp;
4034 int count;
4035 int b_idx;
4036 int dring_size;
4037 int cancelled = 0;
4038
4039 ASSERT(MUTEX_HELD(&vdcp->lock));
4040 ASSERT(vdcp->state == VDC_STATE_FAILED);
4041
4042 if (vdcp->local_dring_backup == NULL) {
4043 /* the pending requests have already been processed */
4044 return;
4045 }
4046
4047 DMSG(vdcp, 1, "cancelling pending dring entries (len=%d, tail=%d)\n",
4048 vdcp->local_dring_backup_len, vdcp->local_dring_backup_tail);
4049
4050 /*
4051 * Walk the backup copy of the local descriptor ring and
4052 * cancel all the outstanding transactions.
4053 */
4054 b_idx = vdcp->local_dring_backup_tail;
4055 for (count = 0; count < vdcp->local_dring_backup_len; count++) {
4056
4057 ldep = &(vdcp->local_dring_backup[b_idx]);
4058
4059 /* only cancel outstanding transactions */
4060 if (!ldep->is_free) {
4061
4062 DMSG(vdcp, 1, "cancelling entry idx=%x\n", b_idx);
4063 cancelled++;
4064
4065 /*
4066 * All requests have already been cleared from the
4067 * local descriptor ring and the LDC channel has been
4068 * reset so we will never get any reply for these
4069 * requests. Now we just have to notify threads waiting
4070 * for replies that the request has failed.
4071 */
4072 bufp = ldep->buf;
4073 ASSERT(bufp != NULL);
4074 bufp->b_resid = bufp->b_bcount;
4075 if (ldep->operation == VD_OP_BREAD ||
4076 ldep->operation == VD_OP_BWRITE) {
4077 VD_UPDATE_ERR_STATS(vdcp, vd_softerrs);
4078 VD_KSTAT_WAITQ_EXIT(vdcp);
4079 DTRACE_IO1(done, buf_t *, bufp);
4080 }
4081 bioerror(bufp, EIO);
4082 biodone(bufp);
4083 }
4084
4085 /* get the next element to cancel */
4086 if (++b_idx >= vdcp->local_dring_backup_len)
4087 b_idx = 0;
4088 }
4089
4090 /* all done - now clear up pending dring copy */
4091 dring_size = vdcp->local_dring_backup_len *
4092 sizeof (vdcp->local_dring_backup[0]);
4093
4094 (void) kmem_free(vdcp->local_dring_backup, dring_size);
4095
4096 vdcp->local_dring_backup = NULL;
4097
4098 DTRACE_PROBE2(cancelled, int, cancelled, vdc_t *, vdcp);
4099 }
4100
4101 /*
4102 * Function:
4103 * vdc_connection_timeout
4104 *
4105 * Description:
4106 * This function is invoked if the timeout set to establish the connection
4107 * with vds expires. This will happen if we spend too much time in the
4108 * VDC_STATE_INIT_WAITING, VDC_STATE_NEGOTIATE or VDC_STATE_HANDLE_PENDING
4109 * states.
4110 *
4111 * Arguments:
4112 * arg - argument of the timeout function actually a soft state
4113 * pointer for the instance of the device driver.
4114 *
4115 * Return Code:
4116 * None
4117 */
4118 void
4119 vdc_connection_timeout(void *arg)
4120 {
4121 vdc_t *vdcp = (vdc_t *)arg;
4122
4123 mutex_enter(&vdcp->lock);
4124
4125 vdcp->ctimeout_reached = B_TRUE;
4126
4127 mutex_exit(&vdcp->lock);
4128 }
4129
4130 /*
4131 * Function:
4132 * vdc_backup_local_dring()
4133 *
4134 * Description:
4135 * Backup the current dring in the event of a reset. The Dring
4136 * transactions will be resubmitted to the server when the
4137 * connection is restored.
4138 *
4139 * Arguments:
4140 * vdcp - soft state pointer for this instance of the device driver.
4141 *
4142 * Return Code:
4143 * NONE
4144 */
4145 static void
4146 vdc_backup_local_dring(vdc_t *vdcp)
4147 {
4148 int b_idx, count, dring_size;
4149 vdc_local_desc_t *curr_ldep;
4150
4151 ASSERT(MUTEX_HELD(&vdcp->lock));
4152 ASSERT(vdcp->state == VDC_STATE_RESETTING);
4153
4154 /*
4155 * If the backup dring is stil around, it means
4156 * that the last restore did not complete. However,
4157 * since we never got back into the running state,
4158 * the backup copy we have is still valid.
4159 */
4160 if (vdcp->local_dring_backup != NULL) {
4161 DMSG(vdcp, 1, "reusing local descriptor ring backup "
4162 "(len=%d, tail=%d)\n", vdcp->local_dring_backup_len,
4163 vdcp->local_dring_backup_tail);
4164 return;
4165 }
4166
4167 /*
4168 * The backup dring can be NULL and the local dring may not be
4169 * initialized. This can happen if we had a reset while establishing
4170 * a new connection but after the connection has timed out. In that
4171 * case the backup dring is NULL because the requests have been
4172 * cancelled and the request occured before the local dring is
4173 * initialized.
4174 */
4175 if (!(vdcp->initialized & VDC_DRING_LOCAL))
4176 return;
4177
4178 DMSG(vdcp, 1, "backing up the local descriptor ring (len=%d, "
4179 "tail=%d)\n", vdcp->dring_len, vdcp->dring_curr_idx);
4180
4181 dring_size = vdcp->dring_len * sizeof (vdcp->local_dring[0]);
4182
4183 vdcp->local_dring_backup = kmem_alloc(dring_size, KM_SLEEP);
4184 bcopy(vdcp->local_dring, vdcp->local_dring_backup, dring_size);
4185
4186 vdcp->local_dring_backup_tail = vdcp->dring_curr_idx;
4187 vdcp->local_dring_backup_len = vdcp->dring_len;
4188
4189 /*
4190 * At this point, pending read or write I/Os are recorded in the
4191 * runq. We update the I/O statistics to indicate that they are now
4192 * back in the waitq.
4193 */
4194 b_idx = vdcp->local_dring_backup_tail;
4195 for (count = 0; count < vdcp->local_dring_backup_len; count++) {
4196
4197 curr_ldep = &(vdcp->local_dring_backup[b_idx]);
4198
4199 if (!curr_ldep->is_free &&
4200 (curr_ldep->operation == VD_OP_BREAD ||
4201 curr_ldep->operation == VD_OP_BWRITE)) {
4202 VD_KSTAT_RUNQ_BACK_TO_WAITQ(vdcp);
4203 }
4204
4205 /* get the next element */
4206 if (++b_idx >= vdcp->local_dring_backup_len)
4207 b_idx = 0;
4208 }
4209
4210 }
4211
4212 static void
4213 vdc_switch_server(vdc_t *vdcp)
4214 {
4215 int rv;
4216 vdc_server_t *curr_server, *new_server;
4217
4218 ASSERT(MUTEX_HELD(&vdcp->lock));
4219
4220 /* if there is only one server return back */
4221 if (vdcp->num_servers == 1) {
4222 return;
4223 }
4224
4225 /* Get current and next server */
4226 curr_server = vdcp->curr_server;
4227 new_server =
4228 (curr_server->next) ? curr_server->next : vdcp->server_list;
4229 ASSERT(curr_server != new_server);
4230
4231 /* bring current server's channel down */
4232 rv = ldc_down(curr_server->ldc_handle);
4233 if (rv) {
4234 DMSG(vdcp, 0, "[%d] Cannot bring channel down, port %ld\n",
4235 vdcp->instance, curr_server->id);
4236 return;
4237 }
4238
4239 /* switch the server */
4240 vdcp->curr_server = new_server;
4241
4242 DMSG(vdcp, 0, "[%d] Switched to next vdisk server, port@%ld, ldc@%ld\n",
4243 vdcp->instance, vdcp->curr_server->id, vdcp->curr_server->ldc_id);
4244 }
4245
4246 static void
4247 vdc_print_svc_status(vdc_t *vdcp)
4248 {
4249 int instance;
4250 uint64_t ldc_id, port_id;
4251 vdc_service_state_t svc_state;
4252
4253 ASSERT(mutex_owned(&vdcp->lock));
4254
4255 svc_state = vdcp->curr_server->svc_state;
4256
4257 if (vdcp->curr_server->log_state == svc_state)
4258 return;
4259
4260 instance = vdcp->instance;
4261 ldc_id = vdcp->curr_server->ldc_id;
4262 port_id = vdcp->curr_server->id;
4263
4264 switch (svc_state) {
4265
4266 case VDC_SERVICE_OFFLINE:
4267 cmn_err(CE_CONT, "?vdisk@%d is offline\n", instance);
4268 break;
4269
4270 case VDC_SERVICE_CONNECTED:
4271 cmn_err(CE_CONT, "?vdisk@%d is connected using ldc@%ld,%ld\n",
4272 instance, ldc_id, port_id);
4273 break;
4274
4275 case VDC_SERVICE_ONLINE:
4276 cmn_err(CE_CONT, "?vdisk@%d is online using ldc@%ld,%ld\n",
4277 instance, ldc_id, port_id);
4278 break;
4279
4280 case VDC_SERVICE_FAILED:
4281 cmn_err(CE_CONT, "?vdisk@%d access to service failed "
4282 "using ldc@%ld,%ld\n", instance, ldc_id, port_id);
4283 break;
4284
4285 case VDC_SERVICE_FAULTED:
4286 cmn_err(CE_CONT, "?vdisk@%d access to backend failed "
4287 "using ldc@%ld,%ld\n", instance, ldc_id, port_id);
4288 break;
4289
4290 default:
4291 ASSERT(0);
4292 break;
4293 }
4294
4295 vdcp->curr_server->log_state = svc_state;
4296 }
4297
4298 /*
4299 * Function:
4300 * vdc_handshake_retry
4301 *
4302 * Description:
4303 * This function indicates if the handshake should be retried or not.
4304 * This depends on the lifecycle of the driver:
4305 *
4306 * VDC_LC_ATTACHING: the handshake is retried until we have tried
4307 * a handshake with each server. We don't care how far each handshake
4308 * went, the goal is just to try the handshake. We want to minimize the
4309 * the time spent doing the attach because this is locking the device
4310 * tree.
4311 *
4312 * VDC_LC_ONLINE_PENDING: the handshake is retried while we haven't done
4313 * consecutive attribute negotiations with each server, and we haven't
4314 * reached a minimum total of consecutive negotiations (hattr_min). The
4315 * number of attribution negotiations determines the time spent before
4316 * failing pending I/Os if the handshake is not successful.
4317 *
4318 * VDC_LC_ONLINE: the handshake is always retried, until we have a
4319 * successful handshake with a server.
4320 *
4321 * VDC_LC_DETACHING: N/A
4322 *
4323 * Arguments:
4324 * hshake_cnt - number of handshake attempts
4325 * hattr_cnt - number of attribute negotiation attempts
4326 *
4327 * Return Code:
4328 * B_TRUE - handshake should be retried
4329 * B_FALSE - handshake should not be retried
4330 */
4331 static boolean_t
4332 vdc_handshake_retry(vdc_t *vdcp, int hshake_cnt, int hattr_cnt)
4333 {
4334 int hattr_total = 0;
4335 vdc_server_t *srvr;
4336
4337 ASSERT(vdcp->lifecycle != VDC_LC_DETACHING);
4338
4339 /* update handshake counters */
4340 vdcp->curr_server->hshake_cnt = hshake_cnt;
4341 vdcp->curr_server->hattr_cnt = hattr_cnt;
4342
4343 /*
4344 * If no attribute negotiation was done then we reset the total
4345 * number otherwise we cumulate the number.
4346 */
4347 if (hattr_cnt == 0)
4348 vdcp->curr_server->hattr_total = 0;
4349 else
4350 vdcp->curr_server->hattr_total += hattr_cnt;
4351
4352 /*
4353 * If we are online (i.e. at least one handshake was successfully
4354 * completed) then we always retry the handshake.
4355 */
4356 if (vdcp->lifecycle == VDC_LC_ONLINE)
4357 return (B_TRUE);
4358
4359 /*
4360 * If we are attaching then we retry the handshake only if we haven't
4361 * tried with all servers.
4362 */
4363 if (vdcp->lifecycle == VDC_LC_ATTACHING) {
4364
4365 for (srvr = vdcp->server_list; srvr != NULL;
4366 srvr = srvr->next) {
4367 if (srvr->hshake_cnt == 0) {
4368 return (B_TRUE);
4369 }
4370 }
4371
4372 return (B_FALSE);
4373 }
4374
4375 /*
4376 * Here we are in the case where we haven't completed any handshake
4377 * successfully yet.
4378 */
4379 ASSERT(vdcp->lifecycle == VDC_LC_ONLINE_PENDING);
4380
4381 /*
4382 * We retry the handshake if we haven't done an attribute negotiation
4383 * with each server. This is to handle the case where one service domain
4384 * is down.
4385 */
4386 for (srvr = vdcp->server_list; srvr != NULL; srvr = srvr->next) {
4387 if (srvr->hattr_cnt == 0) {
4388 return (B_TRUE);
4389 }
4390 hattr_total += srvr->hattr_total;
4391 }
4392
4393 /*
4394 * We retry the handshake if we haven't reached the minimum number of
4395 * attribute negotiation.
4396 */
4397 return (hattr_total < vdcp->hattr_min);
4398 }
4399
4400 /* -------------------------------------------------------------------------- */
4401
4402 /*
4403 * The following functions process the incoming messages from vds
4404 */
4405
4406 /*
4407 * Function:
4408 * vdc_process_msg_thread()
4409 *
4410 * Description:
4411 *
4412 * Main VDC message processing thread. Each vDisk instance
4413 * consists of a copy of this thread. This thread triggers
4414 * all the handshakes and data exchange with the server. It
4415 * also handles all channel resets
4416 *
4417 * Arguments:
4418 * vdc - soft state pointer for this instance of the device driver.
4419 *
4420 * Return Code:
4421 * None
4422 */
4423 static void
4424 vdc_process_msg_thread(vdc_t *vdcp)
4425 {
4426 boolean_t failure_msg = B_FALSE;
4427 int status;
4428 int ctimeout;
4429 timeout_id_t tmid = 0;
4430 clock_t ldcup_timeout = 0;
4431 vdc_server_t *srvr;
4432 vdc_service_state_t svc_state;
4433 int hshake_cnt = 0;
4434 int hattr_cnt = 0;
4435
4436 mutex_enter(&vdcp->lock);
4437
4438 ASSERT(vdcp->lifecycle == VDC_LC_ATTACHING);
4439
4440 for (;;) {
4441
4442 #define Q(_s) (vdcp->state == _s) ? #_s :
4443 DMSG(vdcp, 3, "state = %d (%s)\n", vdcp->state,
4444 Q(VDC_STATE_INIT)
4445 Q(VDC_STATE_INIT_WAITING)
4446 Q(VDC_STATE_NEGOTIATE)
4447 Q(VDC_STATE_HANDLE_PENDING)
4448 Q(VDC_STATE_FAULTED)
4449 Q(VDC_STATE_FAILED)
4450 Q(VDC_STATE_RUNNING)
4451 Q(VDC_STATE_RESETTING)
4452 Q(VDC_STATE_DETACH)
4453 "UNKNOWN");
4454 #undef Q
4455
4456 switch (vdcp->state) {
4457 case VDC_STATE_INIT:
4458
4459 /*
4460 * If requested, start a timeout to check if the
4461 * connection with vds is established in the
4462 * specified delay. If the timeout expires, we
4463 * will cancel any pending request.
4464 *
4465 * If some reset have occurred while establishing
4466 * the connection, we already have a timeout armed
4467 * and in that case we don't need to arm a new one.
4468 *
4469 * The same rule applies when there are multiple vds'.
4470 * If either a connection cannot be established or
4471 * the handshake times out, the connection thread will
4472 * try another server. The 'ctimeout' will report
4473 * back an error after it expires irrespective of
4474 * whether the vdisk is trying to connect to just
4475 * one or multiple servers.
4476 */
4477 ctimeout = (vdc_timeout != 0)?
4478 vdc_timeout : vdcp->curr_server->ctimeout;
4479
4480 if (ctimeout != 0 && tmid == 0) {
4481 tmid = timeout(vdc_connection_timeout, vdcp,
4482 ctimeout * drv_usectohz(MICROSEC));
4483 }
4484
4485 /* Switch to STATE_DETACH if drv is detaching */
4486 if (vdcp->lifecycle == VDC_LC_DETACHING) {
4487 vdcp->state = VDC_STATE_DETACH;
4488 break;
4489 }
4490
4491 /* Check if the timeout has been reached */
4492 if (vdcp->ctimeout_reached) {
4493 ASSERT(tmid != 0);
4494 tmid = 0;
4495 vdcp->state = VDC_STATE_FAILED;
4496 break;
4497 }
4498
4499 /*
4500 * Switch to another server when we reach the limit of
4501 * the number of handshake per server or if we have done
4502 * an attribute negotiation.
4503 */
4504 if (hshake_cnt >= vdc_hshake_retries || hattr_cnt > 0) {
4505
4506 if (!vdc_handshake_retry(vdcp, hshake_cnt,
4507 hattr_cnt)) {
4508 DMSG(vdcp, 0, "[%d] too many "
4509 "handshakes", vdcp->instance);
4510 vdcp->state = VDC_STATE_FAILED;
4511 break;
4512 }
4513
4514 vdc_switch_server(vdcp);
4515
4516 hshake_cnt = 0;
4517 hattr_cnt = 0;
4518 }
4519
4520 hshake_cnt++;
4521
4522 /* Bring up connection with vds via LDC */
4523 status = vdc_start_ldc_connection(vdcp);
4524 if (status != EINVAL) {
4525 vdcp->state = VDC_STATE_INIT_WAITING;
4526 } else {
4527 vdcp->curr_server->svc_state =
4528 VDC_SERVICE_FAILED;
4529 vdc_print_svc_status(vdcp);
4530 }
4531 break;
4532
4533 case VDC_STATE_INIT_WAITING:
4534
4535 /* if channel is UP, start negotiation */
4536 if (vdcp->curr_server->ldc_state == LDC_UP) {
4537 vdcp->state = VDC_STATE_NEGOTIATE;
4538 break;
4539 }
4540
4541 /*
4542 * Wait for LDC_UP. If it times out and we have multiple
4543 * servers then we will retry using a different server.
4544 */
4545 ldcup_timeout = ddi_get_lbolt() + (vdc_ldcup_timeout *
4546 drv_usectohz(MICROSEC));
4547 status = cv_timedwait(&vdcp->initwait_cv, &vdcp->lock,
4548 ldcup_timeout);
4549 if (status == -1 &&
4550 vdcp->state == VDC_STATE_INIT_WAITING &&
4551 vdcp->curr_server->ldc_state != LDC_UP) {
4552 /* timed out & still waiting */
4553 vdcp->curr_server->svc_state =
4554 VDC_SERVICE_FAILED;
4555 vdc_print_svc_status(vdcp);
4556 vdcp->state = VDC_STATE_INIT;
4557 break;
4558 }
4559
4560 if (vdcp->state != VDC_STATE_INIT_WAITING) {
4561 DMSG(vdcp, 0,
4562 "state moved to %d out from under us...\n",
4563 vdcp->state);
4564 }
4565 break;
4566
4567 case VDC_STATE_NEGOTIATE:
4568 switch (status = vdc_ver_negotiation(vdcp)) {
4569 case 0:
4570 break;
4571 default:
4572 DMSG(vdcp, 0, "ver negotiate failed (%d)..\n",
4573 status);
4574 goto reset;
4575 }
4576
4577 hattr_cnt++;
4578
4579 switch (status = vdc_attr_negotiation(vdcp)) {
4580 case 0:
4581 break;
4582 default:
4583 DMSG(vdcp, 0, "attr negotiate failed (%d)..\n",
4584 status);
4585 goto reset;
4586 }
4587
4588 switch (status = vdc_dring_negotiation(vdcp)) {
4589 case 0:
4590 break;
4591 default:
4592 DMSG(vdcp, 0, "dring negotiate failed (%d)..\n",
4593 status);
4594 goto reset;
4595 }
4596
4597 switch (status = vdc_rdx_exchange(vdcp)) {
4598 case 0:
4599 vdcp->state = VDC_STATE_HANDLE_PENDING;
4600 goto done;
4601 default:
4602 DMSG(vdcp, 0, "RDX xchg failed ..(%d)\n",
4603 status);
4604 goto reset;
4605 }
4606 reset:
4607 DMSG(vdcp, 0, "negotiation failed: resetting (%d)\n",
4608 status);
4609 vdcp->state = VDC_STATE_RESETTING;
4610 vdcp->self_reset = B_TRUE;
4611 vdcp->curr_server->svc_state = VDC_SERVICE_FAILED;
4612 vdc_print_svc_status(vdcp);
4613 done:
4614 DMSG(vdcp, 0, "negotiation complete (state=0x%x)...\n",
4615 vdcp->state);
4616 break;
4617
4618 case VDC_STATE_HANDLE_PENDING:
4619
4620 DMSG(vdcp, 0, "[%d] connection to service domain is up",
4621 vdcp->instance);
4622 vdcp->curr_server->svc_state = VDC_SERVICE_CONNECTED;
4623
4624 mutex_exit(&vdcp->lock);
4625
4626 /*
4627 * If we have multiple servers, check that the backend
4628 * is effectively available before resubmitting any IO.
4629 */
4630 if (vdcp->num_servers > 1 &&
4631 vdc_eio_check(vdcp, 0) != 0) {
4632 mutex_enter(&vdcp->lock);
4633 vdcp->curr_server->svc_state =
4634 VDC_SERVICE_FAULTED;
4635 vdcp->state = VDC_STATE_FAULTED;
4636 break;
4637 }
4638
4639 if (tmid != 0) {
4640 (void) untimeout(tmid);
4641 tmid = 0;
4642 vdcp->ctimeout_reached = B_FALSE;
4643 }
4644
4645 /*
4646 * Setup devid
4647 */
4648 (void) vdc_setup_devid(vdcp);
4649
4650 status = vdc_resubmit_backup_dring(vdcp);
4651
4652 mutex_enter(&vdcp->lock);
4653
4654 if (status) {
4655 vdcp->state = VDC_STATE_RESETTING;
4656 vdcp->self_reset = B_TRUE;
4657 vdcp->curr_server->svc_state =
4658 VDC_SERVICE_FAILED;
4659 vdc_print_svc_status(vdcp);
4660 } else {
4661 vdcp->state = VDC_STATE_RUNNING;
4662 }
4663 break;
4664
4665 case VDC_STATE_FAULTED:
4666 /*
4667 * Server is faulted because the backend is unavailable.
4668 * If all servers are faulted then we mark the service
4669 * as failed, otherwise we reset to switch to another
4670 * server.
4671 */
4672 vdc_print_svc_status(vdcp);
4673
4674 /* check if all servers are faulted */
4675 for (srvr = vdcp->server_list; srvr != NULL;
4676 srvr = srvr->next) {
4677 svc_state = srvr->svc_state;
4678 if (svc_state != VDC_SERVICE_FAULTED)
4679 break;
4680 }
4681
4682 if (srvr != NULL) {
4683 vdcp->state = VDC_STATE_RESETTING;
4684 vdcp->self_reset = B_TRUE;
4685 } else {
4686 vdcp->state = VDC_STATE_FAILED;
4687 }
4688 break;
4689
4690 case VDC_STATE_FAILED:
4691 /*
4692 * We reach this state when we are unable to access the
4693 * backend from any server, either because of a maximum
4694 * connection retries or timeout, or because the backend
4695 * is unavailable.
4696 *
4697 * Then we cancel the backup DRing so that errors get
4698 * reported and we wait for a new I/O before attempting
4699 * another connection.
4700 */
4701
4702 cmn_err(CE_NOTE, "vdisk@%d disk access failed",
4703 vdcp->instance);
4704 failure_msg = B_TRUE;
4705
4706 if (vdcp->lifecycle == VDC_LC_ATTACHING) {
4707 vdcp->lifecycle = VDC_LC_ONLINE_PENDING;
4708 vdcp->hattr_min = vdc_hattr_min_initial;
4709 } else {
4710 vdcp->hattr_min = vdc_hattr_min;
4711 }
4712
4713 /* cancel any timeout */
4714 if (tmid != 0) {
4715 (void) untimeout(tmid);
4716 tmid = 0;
4717 }
4718
4719 /* cancel pending I/Os */
4720 cv_broadcast(&vdcp->running_cv);
4721 vdc_cancel_backup_dring(vdcp);
4722
4723 /* wait for new I/O */
4724 while (!vdcp->io_pending)
4725 cv_wait(&vdcp->io_pending_cv, &vdcp->lock);
4726
4727 /*
4728 * There's a new IO pending. Try to re-establish a
4729 * connection. Mark all services as offline, so that
4730 * we don't stop again before having retried all
4731 * servers.
4732 */
4733 for (srvr = vdcp->server_list; srvr != NULL;
4734 srvr = srvr->next) {
4735 srvr->svc_state = VDC_SERVICE_OFFLINE;
4736 srvr->hshake_cnt = 0;
4737 srvr->hattr_cnt = 0;
4738 srvr->hattr_total = 0;
4739 }
4740
4741 /* reset variables */
4742 hshake_cnt = 0;
4743 hattr_cnt = 0;
4744 vdcp->ctimeout_reached = B_FALSE;
4745
4746 vdcp->state = VDC_STATE_RESETTING;
4747 vdcp->self_reset = B_TRUE;
4748 break;
4749
4750 /* enter running state */
4751 case VDC_STATE_RUNNING:
4752
4753 if (vdcp->lifecycle == VDC_LC_DETACHING) {
4754 vdcp->state = VDC_STATE_DETACH;
4755 break;
4756 }
4757
4758 vdcp->lifecycle = VDC_LC_ONLINE;
4759
4760 if (failure_msg) {
4761 cmn_err(CE_NOTE, "vdisk@%d disk access "
4762 "recovered", vdcp->instance);
4763 failure_msg = B_FALSE;
4764 }
4765
4766 /*
4767 * Signal anyone waiting for the connection
4768 * to come on line.
4769 */
4770 cv_broadcast(&vdcp->running_cv);
4771
4772 /* backend has to be checked after reset */
4773 if (vdcp->failfast_interval != 0 ||
4774 vdcp->num_servers > 1)
4775 cv_signal(&vdcp->eio_cv);
4776
4777 /* ownership is lost during reset */
4778 if (vdcp->ownership & VDC_OWNERSHIP_WANTED)
4779 vdcp->ownership |= VDC_OWNERSHIP_RESET;
4780 cv_signal(&vdcp->ownership_cv);
4781
4782 vdcp->curr_server->svc_state = VDC_SERVICE_ONLINE;
4783 vdc_print_svc_status(vdcp);
4784
4785 mutex_exit(&vdcp->lock);
4786
4787 for (;;) {
4788 vio_msg_t msg;
4789 status = vdc_wait_for_response(vdcp, &msg);
4790 if (status) break;
4791
4792 DMSG(vdcp, 1, "[%d] new pkt(s) available\n",
4793 vdcp->instance);
4794 status = vdc_process_data_msg(vdcp, &msg);
4795 if (status) {
4796 DMSG(vdcp, 1, "[%d] process_data_msg "
4797 "returned err=%d\n", vdcp->instance,
4798 status);
4799 break;
4800 }
4801
4802 }
4803
4804 mutex_enter(&vdcp->lock);
4805
4806 /* all servers are now offline */
4807 for (srvr = vdcp->server_list; srvr != NULL;
4808 srvr = srvr->next) {
4809 srvr->svc_state = VDC_SERVICE_OFFLINE;
4810 srvr->log_state = VDC_SERVICE_NONE;
4811 srvr->hshake_cnt = 0;
4812 srvr->hattr_cnt = 0;
4813 srvr->hattr_total = 0;
4814 }
4815
4816 hshake_cnt = 0;
4817 hattr_cnt = 0;
4818
4819 vdc_print_svc_status(vdcp);
4820
4821 vdcp->state = VDC_STATE_RESETTING;
4822 vdcp->self_reset = B_TRUE;
4823 break;
4824
4825 case VDC_STATE_RESETTING:
4826 /*
4827 * When we reach this state, we either come from the
4828 * VDC_STATE_RUNNING state and we can have pending
4829 * request but no timeout is armed; or we come from
4830 * the VDC_STATE_INIT_WAITING, VDC_NEGOTIATE or
4831 * VDC_HANDLE_PENDING state and there is no pending
4832 * request or pending requests have already been copied
4833 * into the backup dring. So we can safely keep the
4834 * connection timeout armed while we are in this state.
4835 */
4836
4837 DMSG(vdcp, 0, "Initiating channel reset "
4838 "(pending = %d)\n", (int)vdcp->threads_pending);
4839
4840 if (vdcp->self_reset) {
4841 DMSG(vdcp, 0,
4842 "[%d] calling stop_ldc_connection.\n",
4843 vdcp->instance);
4844 status = vdc_stop_ldc_connection(vdcp);
4845 vdcp->self_reset = B_FALSE;
4846 }
4847
4848 /*
4849 * Wait for all threads currently waiting
4850 * for a free dring entry to use.
4851 */
4852 while (vdcp->threads_pending) {
4853 cv_broadcast(&vdcp->membind_cv);
4854 cv_broadcast(&vdcp->dring_free_cv);
4855 mutex_exit(&vdcp->lock);
4856 /* give the waiters enough time to wake up */
4857 delay(vdc_hz_min_ldc_delay);
4858 mutex_enter(&vdcp->lock);
4859 }
4860
4861 ASSERT(vdcp->threads_pending == 0);
4862
4863 /* Sanity check that no thread is receiving */
4864 ASSERT(vdcp->read_state != VDC_READ_WAITING);
4865
4866 vdcp->read_state = VDC_READ_IDLE;
4867 vdcp->io_pending = B_FALSE;
4868
4869 /*
4870 * Cleanup any pending eio. These I/Os are going to
4871 * be resubmitted.
4872 */
4873 vdc_eio_unqueue(vdcp, 0, B_FALSE);
4874
4875 vdc_backup_local_dring(vdcp);
4876
4877 /* cleanup the old d-ring */
4878 vdc_destroy_descriptor_ring(vdcp);
4879
4880 /* go and start again */
4881 vdcp->state = VDC_STATE_INIT;
4882
4883 break;
4884
4885 case VDC_STATE_DETACH:
4886 DMSG(vdcp, 0, "[%d] Reset thread exit cleanup ..\n",
4887 vdcp->instance);
4888
4889 /* cancel any pending timeout */
4890 mutex_exit(&vdcp->lock);
4891 if (tmid != 0) {
4892 (void) untimeout(tmid);
4893 tmid = 0;
4894 }
4895 mutex_enter(&vdcp->lock);
4896
4897 /*
4898 * Signal anyone waiting for connection
4899 * to come online
4900 */
4901 cv_broadcast(&vdcp->running_cv);
4902
4903 while (vdcp->sync_op_cnt > 0) {
4904 cv_broadcast(&vdcp->sync_blocked_cv);
4905 mutex_exit(&vdcp->lock);
4906 /* give the waiters enough time to wake up */
4907 delay(vdc_hz_min_ldc_delay);
4908 mutex_enter(&vdcp->lock);
4909 }
4910
4911 mutex_exit(&vdcp->lock);
4912
4913 DMSG(vdcp, 0, "[%d] Msg processing thread exiting ..\n",
4914 vdcp->instance);
4915 thread_exit();
4916 break;
4917 }
4918 }
4919 }
4920
4921
4922 /*
4923 * Function:
4924 * vdc_process_data_msg()
4925 *
4926 * Description:
4927 * This function is called by the message processing thread each time
4928 * a message with a msgtype of VIO_TYPE_DATA is received. It will either
4929 * be an ACK or NACK from vds[1] which vdc handles as follows.
4930 * ACK - wake up the waiting thread
4931 * NACK - resend any messages necessary
4932 *
4933 * [1] Although the message format allows it, vds should not send a
4934 * VIO_SUBTYPE_INFO message to vdc asking it to read data; if for
4935 * some bizarre reason it does, vdc will reset the connection.
4936 *
4937 * Arguments:
4938 * vdc - soft state pointer for this instance of the device driver.
4939 * msg - the LDC message sent by vds
4940 *
4941 * Return Code:
4942 * 0 - Success.
4943 * > 0 - error value returned by LDC
4944 */
4945 static int
4946 vdc_process_data_msg(vdc_t *vdcp, vio_msg_t *msg)
4947 {
4948 int status = 0;
4949 vio_dring_msg_t *dring_msg;
4950 vdc_local_desc_t *ldep = NULL;
4951 int start, end;
4952 int idx;
4953 int op;
4954
4955 dring_msg = (vio_dring_msg_t *)msg;
4956
4957 ASSERT(msg->tag.vio_msgtype == VIO_TYPE_DATA);
4958 ASSERT(vdcp != NULL);
4959
4960 mutex_enter(&vdcp->lock);
4961
4962 /*
4963 * Check to see if the message has bogus data
4964 */
4965 idx = start = dring_msg->start_idx;
4966 end = dring_msg->end_idx;
4967 if ((start >= vdcp->dring_len) ||
4968 (end >= vdcp->dring_len) || (end < -1)) {
4969 /*
4970 * Update the I/O statistics to indicate that an error ocurred.
4971 * No need to update the wait/run queues as no specific read or
4972 * write request is being completed in response to this 'msg'.
4973 */
4974 VD_UPDATE_ERR_STATS(vdcp, vd_softerrs);
4975 DMSG(vdcp, 0, "[%d] Bogus ACK data : start %d, end %d\n",
4976 vdcp->instance, start, end);
4977 mutex_exit(&vdcp->lock);
4978 return (EINVAL);
4979 }
4980
4981 /*
4982 * Verify that the sequence number is what vdc expects.
4983 */
4984 switch (vdc_verify_seq_num(vdcp, dring_msg)) {
4985 case VDC_SEQ_NUM_TODO:
4986 break; /* keep processing this message */
4987 case VDC_SEQ_NUM_SKIP:
4988 mutex_exit(&vdcp->lock);
4989 return (0);
4990 case VDC_SEQ_NUM_INVALID:
4991 /*
4992 * Update the I/O statistics to indicate that an error ocurred.
4993 * No need to update the wait/run queues as no specific read or
4994 * write request is being completed in response to this 'msg'.
4995 */
4996 VD_UPDATE_ERR_STATS(vdcp, vd_softerrs);
4997 DMSG(vdcp, 0, "[%d] invalid seqno\n", vdcp->instance);
4998 mutex_exit(&vdcp->lock);
4999 return (ENXIO);
5000 }
5001
5002 if (msg->tag.vio_subtype == VIO_SUBTYPE_NACK) {
5003 /*
5004 * Update the I/O statistics to indicate that an error ocurred.
5005 * No need to update the wait/run queues, this will be done by
5006 * the thread calling this function.
5007 */
5008 VD_UPDATE_ERR_STATS(vdcp, vd_softerrs);
5009 VDC_DUMP_DRING_MSG(dring_msg);
5010 DMSG(vdcp, 0, "[%d] DATA NACK\n", vdcp->instance);
5011 mutex_exit(&vdcp->lock);
5012 return (EIO);
5013
5014 } else if (msg->tag.vio_subtype == VIO_SUBTYPE_INFO) {
5015 /*
5016 * Update the I/O statistics to indicate that an error occurred.
5017 * No need to update the wait/run queues as no specific read or
5018 * write request is being completed in response to this 'msg'.
5019 */
5020 VD_UPDATE_ERR_STATS(vdcp, vd_protoerrs);
5021 mutex_exit(&vdcp->lock);
5022 return (EPROTO);
5023 }
5024
5025 DMSG(vdcp, 1, ": start %d end %d\n", start, end);
5026 ASSERT(start == end);
5027
5028 ldep = &vdcp->local_dring[idx];
5029
5030 DMSG(vdcp, 1, ": state 0x%x\n", ldep->dep->hdr.dstate);
5031
5032 if (ldep->dep->hdr.dstate == VIO_DESC_DONE) {
5033 struct buf *bufp;
5034
5035 status = ldep->dep->payload.status;
5036
5037 bufp = ldep->buf;
5038 ASSERT(bufp != NULL);
5039
5040 bufp->b_resid = bufp->b_bcount - ldep->dep->payload.nbytes;
5041 bioerror(bufp, status);
5042
5043 if (status != 0) {
5044 DMSG(vdcp, 1, "I/O status=%d\n", status);
5045 }
5046
5047 DMSG(vdcp, 1,
5048 "I/O complete req=%ld bytes resp=%ld bytes\n",
5049 bufp->b_bcount, ldep->dep->payload.nbytes);
5050
5051 /*
5052 * If the request has failed and we have multiple servers or
5053 * failfast is enabled then we will have to defer the completion
5054 * of the request until we have checked that the vdisk backend
5055 * is effectively available (if multiple server) or that there
5056 * is no reservation conflict (if failfast).
5057 */
5058 if (status != 0 &&
5059 ((vdcp->num_servers > 1 &&
5060 (ldep->flags & VDC_OP_ERRCHK_BACKEND)) ||
5061 (vdcp->failfast_interval != 0 &&
5062 (ldep->flags & VDC_OP_ERRCHK_CONFLICT)))) {
5063 /*
5064 * The I/O has failed and we need to check the error.
5065 */
5066 (void) vdc_eio_queue(vdcp, idx);
5067 } else {
5068 op = ldep->operation;
5069 if (op == VD_OP_BREAD || op == VD_OP_BWRITE) {
5070 if (status == 0) {
5071 VD_UPDATE_IO_STATS(vdcp, op,
5072 ldep->dep->payload.nbytes);
5073 } else {
5074 VD_UPDATE_ERR_STATS(vdcp, vd_softerrs);
5075 }
5076 VD_KSTAT_RUNQ_EXIT(vdcp);
5077 DTRACE_IO1(done, buf_t *, bufp);
5078 }
5079 (void) vdc_depopulate_descriptor(vdcp, idx);
5080 biodone(bufp);
5081 }
5082 }
5083
5084 /* let the arrival signal propogate */
5085 mutex_exit(&vdcp->lock);
5086
5087 /* probe gives the count of how many entries were processed */
5088 DTRACE_PROBE2(processed, int, 1, vdc_t *, vdcp);
5089
5090 return (0);
5091 }
5092
5093
5094 /*
5095 * Function:
5096 * vdc_handle_ver_msg()
5097 *
5098 * Description:
5099 *
5100 * Arguments:
5101 * vdc - soft state pointer for this instance of the device driver.
5102 * ver_msg - LDC message sent by vDisk server
5103 *
5104 * Return Code:
5105 * 0 - Success
5106 */
5107 static int
5108 vdc_handle_ver_msg(vdc_t *vdc, vio_ver_msg_t *ver_msg)
5109 {
5110 int status = 0;
5111
5112 ASSERT(vdc != NULL);
5113 ASSERT(mutex_owned(&vdc->lock));
5114
5115 if (ver_msg->tag.vio_subtype_env != VIO_VER_INFO) {
5116 return (EPROTO);
5117 }
5118
5119 if (ver_msg->dev_class != VDEV_DISK_SERVER) {
5120 return (EINVAL);
5121 }
5122
5123 switch (ver_msg->tag.vio_subtype) {
5124 case VIO_SUBTYPE_ACK:
5125 /*
5126 * We check to see if the version returned is indeed supported
5127 * (The server may have also adjusted the minor number downwards
5128 * and if so 'ver_msg' will contain the actual version agreed)
5129 */
5130 if (vdc_is_supported_version(ver_msg)) {
5131 vdc->ver.major = ver_msg->ver_major;
5132 vdc->ver.minor = ver_msg->ver_minor;
5133 ASSERT(vdc->ver.major > 0);
5134 } else {
5135 status = EPROTO;
5136 }
5137 break;
5138
5139 case VIO_SUBTYPE_NACK:
5140 /*
5141 * call vdc_is_supported_version() which will return the next
5142 * supported version (if any) in 'ver_msg'
5143 */
5144 (void) vdc_is_supported_version(ver_msg);
5145 if (ver_msg->ver_major > 0) {
5146 size_t len = sizeof (*ver_msg);
5147
5148 ASSERT(vdc->ver.major > 0);
5149
5150 /* reset the necessary fields and resend */
5151 ver_msg->tag.vio_subtype = VIO_SUBTYPE_INFO;
5152 ver_msg->dev_class = VDEV_DISK;
5153
5154 status = vdc_send(vdc, (caddr_t)ver_msg, &len);
5155 DMSG(vdc, 0, "[%d] Resend VER info (LDC status = %d)\n",
5156 vdc->instance, status);
5157 if (len != sizeof (*ver_msg))
5158 status = EBADMSG;
5159 } else {
5160 DMSG(vdc, 0, "[%d] No common version with vDisk server",
5161 vdc->instance);
5162 status = ENOTSUP;
5163 }
5164
5165 break;
5166 case VIO_SUBTYPE_INFO:
5167 /*
5168 * Handle the case where vds starts handshake
5169 * (for now only vdc is the instigator)
5170 */
5171 status = ENOTSUP;
5172 break;
5173
5174 default:
5175 status = EINVAL;
5176 break;
5177 }
5178
5179 return (status);
5180 }
5181
5182 /*
5183 * Function:
5184 * vdc_handle_attr_msg()
5185 *
5186 * Description:
5187 *
5188 * Arguments:
5189 * vdc - soft state pointer for this instance of the device driver.
5190 * attr_msg - LDC message sent by vDisk server
5191 *
5192 * Return Code:
5193 * 0 - Success
5194 */
5195 static int
5196 vdc_handle_attr_msg(vdc_t *vdc, vd_attr_msg_t *attr_msg)
5197 {
5198 int status = 0;
5199 vd_disk_type_t old_type;
5200
5201 ASSERT(vdc != NULL);
5202 ASSERT(mutex_owned(&vdc->lock));
5203
5204 if (attr_msg->tag.vio_subtype_env != VIO_ATTR_INFO) {
5205 return (EPROTO);
5206 }
5207
5208 switch (attr_msg->tag.vio_subtype) {
5209 case VIO_SUBTYPE_ACK:
5210 /*
5211 * We now verify the attributes sent by vds.
5212 */
5213 if (attr_msg->vdisk_size == 0) {
5214 DMSG(vdc, 0, "[%d] Invalid disk size from vds",
5215 vdc->instance);
5216 status = EINVAL;
5217 break;
5218 }
5219
5220 if (attr_msg->max_xfer_sz == 0) {
5221 DMSG(vdc, 0, "[%d] Invalid transfer size from vds",
5222 vdc->instance);
5223 status = EINVAL;
5224 break;
5225 }
5226
5227 if (attr_msg->vdisk_size == VD_SIZE_UNKNOWN) {
5228 DMSG(vdc, 0, "[%d] Unknown disk size from vds",
5229 vdc->instance);
5230 attr_msg->vdisk_size = 0;
5231 }
5232
5233 /* update the VIO block size */
5234 if (attr_msg->vdisk_block_size > 0 &&
5235 vdc_update_vio_bsize(vdc,
5236 attr_msg->vdisk_block_size) != 0) {
5237 DMSG(vdc, 0, "[%d] Invalid block size (%u) from vds",
5238 vdc->instance, attr_msg->vdisk_block_size);
5239 status = EINVAL;
5240 break;
5241 }
5242
5243 /* update disk, block and transfer sizes */
5244 old_type = vdc->vdisk_type;
5245 vdc_update_size(vdc, attr_msg->vdisk_size,
5246 attr_msg->vdisk_block_size, attr_msg->max_xfer_sz);
5247 vdc->vdisk_type = attr_msg->vdisk_type;
5248 vdc->operations = attr_msg->operations;
5249 if (vio_ver_is_supported(vdc->ver, 1, 1))
5250 vdc->vdisk_media = attr_msg->vdisk_media;
5251 else
5252 vdc->vdisk_media = 0;
5253
5254 DMSG(vdc, 0, "[%d] max_xfer_sz: sent %lx acked %lx\n",
5255 vdc->instance, vdc->max_xfer_sz, attr_msg->max_xfer_sz);
5256 DMSG(vdc, 0, "[%d] vdisk_block_size: sent %lx acked %x\n",
5257 vdc->instance, vdc->vdisk_bsize,
5258 attr_msg->vdisk_block_size);
5259
5260 if ((attr_msg->xfer_mode != VIO_DRING_MODE_V1_0) ||
5261 (attr_msg->vdisk_size > INT64_MAX) ||
5262 (attr_msg->operations == 0) ||
5263 (attr_msg->vdisk_type > VD_DISK_TYPE_DISK)) {
5264 DMSG(vdc, 0, "[%d] Invalid attributes from vds",
5265 vdc->instance);
5266 status = EINVAL;
5267 break;
5268 }
5269
5270 /*
5271 * Now that we have received all attributes we can create a
5272 * fake geometry for the disk.
5273 */
5274 vdc_create_fake_geometry(vdc);
5275
5276 /*
5277 * If the disk type was previously unknown and device nodes
5278 * were created then the driver would have created 8 device
5279 * nodes. If we now find out that this is a single-slice disk
5280 * then we need to re-create the appropriate device nodes.
5281 */
5282 if (old_type == VD_DISK_TYPE_UNK &&
5283 (vdc->initialized & VDC_MINOR) &&
5284 vdc->vdisk_type == VD_DISK_TYPE_SLICE) {
5285 ddi_remove_minor_node(vdc->dip, NULL);
5286 (void) devfs_clean(ddi_get_parent(vdc->dip),
5287 NULL, DV_CLEAN_FORCE);
5288 if (vdc_create_device_nodes(vdc) != 0) {
5289 DMSG(vdc, 0, "![%d] Failed to update "
5290 "device nodes", vdc->instance);
5291 }
5292 }
5293
5294 break;
5295
5296 case VIO_SUBTYPE_NACK:
5297 /*
5298 * vds could not handle the attributes we sent so we
5299 * stop negotiating.
5300 */
5301 status = EPROTO;
5302 break;
5303
5304 case VIO_SUBTYPE_INFO:
5305 /*
5306 * Handle the case where vds starts the handshake
5307 * (for now; vdc is the only supported instigatior)
5308 */
5309 status = ENOTSUP;
5310 break;
5311
5312 default:
5313 status = ENOTSUP;
5314 break;
5315 }
5316
5317 return (status);
5318 }
5319
5320 /*
5321 * Function:
5322 * vdc_handle_dring_reg_msg()
5323 *
5324 * Description:
5325 *
5326 * Arguments:
5327 * vdc - soft state pointer for this instance of the driver.
5328 * dring_msg - LDC message sent by vDisk server
5329 *
5330 * Return Code:
5331 * 0 - Success
5332 */
5333 static int
5334 vdc_handle_dring_reg_msg(vdc_t *vdc, vio_dring_reg_msg_t *dring_msg)
5335 {
5336 int status = 0;
5337
5338 ASSERT(vdc != NULL);
5339 ASSERT(mutex_owned(&vdc->lock));
5340
5341 if (dring_msg->tag.vio_subtype_env != VIO_DRING_REG) {
5342 return (EPROTO);
5343 }
5344
5345 switch (dring_msg->tag.vio_subtype) {
5346 case VIO_SUBTYPE_ACK:
5347 /* save the received dring_ident */
5348 vdc->dring_ident = dring_msg->dring_ident;
5349 DMSG(vdc, 0, "[%d] Received dring ident=0x%lx\n",
5350 vdc->instance, vdc->dring_ident);
5351 break;
5352
5353 case VIO_SUBTYPE_NACK:
5354 /*
5355 * vds could not handle the DRing info we sent so we
5356 * stop negotiating.
5357 */
5358 DMSG(vdc, 0, "[%d] server could not register DRing\n",
5359 vdc->instance);
5360 status = EPROTO;
5361 break;
5362
5363 case VIO_SUBTYPE_INFO:
5364 /*
5365 * Handle the case where vds starts handshake
5366 * (for now only vdc is the instigatior)
5367 */
5368 status = ENOTSUP;
5369 break;
5370 default:
5371 status = ENOTSUP;
5372 }
5373
5374 return (status);
5375 }
5376
5377 /*
5378 * Function:
5379 * vdc_verify_seq_num()
5380 *
5381 * Description:
5382 * This functions verifies that the sequence number sent back by the vDisk
5383 * server with the latest message is what is expected (i.e. it is greater
5384 * than the last seq num sent by the vDisk server and less than or equal
5385 * to the last seq num generated by vdc).
5386 *
5387 * It then checks the request ID to see if any requests need processing
5388 * in the DRing.
5389 *
5390 * Arguments:
5391 * vdc - soft state pointer for this instance of the driver.
5392 * dring_msg - pointer to the LDC message sent by vds
5393 *
5394 * Return Code:
5395 * VDC_SEQ_NUM_TODO - Message needs to be processed
5396 * VDC_SEQ_NUM_SKIP - Message has already been processed
5397 * VDC_SEQ_NUM_INVALID - The seq numbers are so out of sync,
5398 * vdc cannot deal with them
5399 */
5400 static int
5401 vdc_verify_seq_num(vdc_t *vdc, vio_dring_msg_t *dring_msg)
5402 {
5403 ASSERT(vdc != NULL);
5404 ASSERT(dring_msg != NULL);
5405 ASSERT(mutex_owned(&vdc->lock));
5406
5407 /*
5408 * Check to see if the messages were responded to in the correct
5409 * order by vds.
5410 */
5411 if ((dring_msg->seq_num <= vdc->seq_num_reply) ||
5412 (dring_msg->seq_num > vdc->seq_num)) {
5413 DMSG(vdc, 0, "?[%d] Bogus sequence_number %lu: "
5414 "%lu > expected <= %lu (last proc req %lu sent %lu)\n",
5415 vdc->instance, dring_msg->seq_num,
5416 vdc->seq_num_reply, vdc->seq_num,
5417 vdc->req_id_proc, vdc->req_id);
5418 return (VDC_SEQ_NUM_INVALID);
5419 }
5420 vdc->seq_num_reply = dring_msg->seq_num;
5421
5422 if (vdc->req_id_proc < vdc->req_id)
5423 return (VDC_SEQ_NUM_TODO);
5424 else
5425 return (VDC_SEQ_NUM_SKIP);
5426 }
5427
5428
5429 /*
5430 * Function:
5431 * vdc_is_supported_version()
5432 *
5433 * Description:
5434 * This routine checks if the major/minor version numbers specified in
5435 * 'ver_msg' are supported. If not it finds the next version that is
5436 * in the supported version list 'vdc_version[]' and sets the fields in
5437 * 'ver_msg' to those values
5438 *
5439 * Arguments:
5440 * ver_msg - LDC message sent by vDisk server
5441 *
5442 * Return Code:
5443 * B_TRUE - Success
5444 * B_FALSE - Version not supported
5445 */
5446 static boolean_t
5447 vdc_is_supported_version(vio_ver_msg_t *ver_msg)
5448 {
5449 int vdc_num_versions = sizeof (vdc_version) / sizeof (vdc_version[0]);
5450
5451 for (int i = 0; i < vdc_num_versions; i++) {
5452 ASSERT(vdc_version[i].major > 0);
5453 ASSERT((i == 0) ||
5454 (vdc_version[i].major < vdc_version[i-1].major));
5455
5456 /*
5457 * If the major versions match, adjust the minor version, if
5458 * necessary, down to the highest value supported by this
5459 * client. The server should support all minor versions lower
5460 * than the value it sent
5461 */
5462 if (ver_msg->ver_major == vdc_version[i].major) {
5463 if (ver_msg->ver_minor > vdc_version[i].minor) {
5464 DMSGX(0,
5465 "Adjusting minor version from %u to %u",
5466 ver_msg->ver_minor, vdc_version[i].minor);
5467 ver_msg->ver_minor = vdc_version[i].minor;
5468 }
5469 return (B_TRUE);
5470 }
5471
5472 /*
5473 * If the message contains a higher major version number, set
5474 * the message's major/minor versions to the current values
5475 * and return false, so this message will get resent with
5476 * these values, and the server will potentially try again
5477 * with the same or a lower version
5478 */
5479 if (ver_msg->ver_major > vdc_version[i].major) {
5480 ver_msg->ver_major = vdc_version[i].major;
5481 ver_msg->ver_minor = vdc_version[i].minor;
5482 DMSGX(0, "Suggesting major/minor (0x%x/0x%x)\n",
5483 ver_msg->ver_major, ver_msg->ver_minor);
5484
5485 return (B_FALSE);
5486 }
5487
5488 /*
5489 * Otherwise, the message's major version is less than the
5490 * current major version, so continue the loop to the next
5491 * (lower) supported version
5492 */
5493 }
5494
5495 /*
5496 * No common version was found; "ground" the version pair in the
5497 * message to terminate negotiation
5498 */
5499 ver_msg->ver_major = 0;
5500 ver_msg->ver_minor = 0;
5501
5502 return (B_FALSE);
5503 }
5504 /* -------------------------------------------------------------------------- */
5505
5506 /*
5507 * DKIO(7) support
5508 */
5509
5510 typedef struct vdc_dk_arg {
5511 struct dk_callback dkc;
5512 int mode;
5513 dev_t dev;
5514 vdc_t *vdc;
5515 } vdc_dk_arg_t;
5516
5517 /*
5518 * Function:
5519 * vdc_dkio_flush_cb()
5520 *
5521 * Description:
5522 * This routine is a callback for DKIOCFLUSHWRITECACHE which can be called
5523 * by kernel code.
5524 *
5525 * Arguments:
5526 * arg - a pointer to a vdc_dk_arg_t structure.
5527 */
5528 void
5529 vdc_dkio_flush_cb(void *arg)
5530 {
5531 struct vdc_dk_arg *dk_arg = (struct vdc_dk_arg *)arg;
5532 struct dk_callback *dkc = NULL;
5533 vdc_t *vdc = NULL;
5534 int rv;
5535
5536 if (dk_arg == NULL) {
5537 cmn_err(CE_NOTE, "?[Unk] DKIOCFLUSHWRITECACHE arg is NULL\n");
5538 return;
5539 }
5540 dkc = &dk_arg->dkc;
5541 vdc = dk_arg->vdc;
5542 ASSERT(vdc != NULL);
5543
5544 rv = vdc_do_sync_op(vdc, VD_OP_FLUSH, NULL, 0,
5545 VDCPART(dk_arg->dev), 0, VIO_both_dir, B_TRUE);
5546 if (rv != 0) {
5547 DMSG(vdc, 0, "[%d] DKIOCFLUSHWRITECACHE failed %d : model %x\n",
5548 vdc->instance, rv,
5549 ddi_model_convert_from(dk_arg->mode & FMODELS));
5550 }
5551
5552 /*
5553 * Trigger the call back to notify the caller the the ioctl call has
5554 * been completed.
5555 */
5556 if ((dk_arg->mode & FKIOCTL) &&
5557 (dkc != NULL) &&
5558 (dkc->dkc_callback != NULL)) {
5559 ASSERT(dkc->dkc_cookie != NULL);
5560 (*dkc->dkc_callback)(dkc->dkc_cookie, rv);
5561 }
5562
5563 /* Indicate that one less DKIO write flush is outstanding */
5564 mutex_enter(&vdc->lock);
5565 vdc->dkio_flush_pending--;
5566 ASSERT(vdc->dkio_flush_pending >= 0);
5567 mutex_exit(&vdc->lock);
5568
5569 /* free the mem that was allocated when the callback was dispatched */
5570 kmem_free(arg, sizeof (vdc_dk_arg_t));
5571 }
5572
5573 /*
5574 * Function:
5575 * vdc_dkio_gapart()
5576 *
5577 * Description:
5578 * This function implements the DKIOCGAPART ioctl.
5579 *
5580 * Arguments:
5581 * vdc - soft state pointer
5582 * arg - a pointer to a dk_map[NDKMAP] or dk_map32[NDKMAP] structure
5583 * flag - ioctl flags
5584 */
5585 static int
5586 vdc_dkio_gapart(vdc_t *vdc, caddr_t arg, int flag)
5587 {
5588 struct dk_geom *geom;
5589 struct extvtoc *vtoc;
5590 union {
5591 struct dk_map map[NDKMAP];
5592 struct dk_map32 map32[NDKMAP];
5593 } data;
5594 int i, rv, size;
5595
5596 mutex_enter(&vdc->lock);
5597
5598 if ((rv = vdc_validate_geometry(vdc)) != 0) {
5599 mutex_exit(&vdc->lock);
5600 return (rv);
5601 }
5602
5603 if (vdc->vdisk_size > VD_OLDVTOC_LIMIT) {
5604 mutex_exit(&vdc->lock);
5605 return (EOVERFLOW);
5606 }
5607
5608 vtoc = vdc->vtoc;
5609 geom = vdc->geom;
5610
5611 if (ddi_model_convert_from(flag & FMODELS) == DDI_MODEL_ILP32) {
5612
5613 for (i = 0; i < vtoc->v_nparts; i++) {
5614 data.map32[i].dkl_cylno = vtoc->v_part[i].p_start /
5615 (geom->dkg_nhead * geom->dkg_nsect);
5616 data.map32[i].dkl_nblk = vtoc->v_part[i].p_size;
5617 }
5618 size = NDKMAP * sizeof (struct dk_map32);
5619
5620 } else {
5621
5622 for (i = 0; i < vtoc->v_nparts; i++) {
5623 data.map[i].dkl_cylno = vtoc->v_part[i].p_start /
5624 (geom->dkg_nhead * geom->dkg_nsect);
5625 data.map[i].dkl_nblk = vtoc->v_part[i].p_size;
5626 }
5627 size = NDKMAP * sizeof (struct dk_map);
5628
5629 }
5630
5631 mutex_exit(&vdc->lock);
5632
5633 if (ddi_copyout(&data, arg, size, flag) != 0)
5634 return (EFAULT);
5635
5636 return (0);
5637 }
5638
5639 /*
5640 * Function:
5641 * vdc_dkio_partition()
5642 *
5643 * Description:
5644 * This function implements the DKIOCPARTITION ioctl.
5645 *
5646 * Arguments:
5647 * vdc - soft state pointer
5648 * arg - a pointer to a struct partition64 structure
5649 * flag - ioctl flags
5650 */
5651 static int
5652 vdc_dkio_partition(vdc_t *vdc, caddr_t arg, int flag)
5653 {
5654 struct partition64 p64;
5655 efi_gpt_t *gpt;
5656 efi_gpe_t *gpe;
5657 vd_efi_dev_t edev;
5658 uint_t partno;
5659 int rv;
5660
5661 if (ddi_copyin(arg, &p64, sizeof (struct partition64), flag)) {
5662 return (EFAULT);
5663 }
5664
5665 VDC_EFI_DEV_SET(edev, vdc, vd_process_efi_ioctl);
5666
5667 if ((rv = vd_efi_alloc_and_read(&edev, &gpt, &gpe)) != 0) {
5668 return (rv);
5669 }
5670
5671 partno = p64.p_partno;
5672
5673 if (partno >= gpt->efi_gpt_NumberOfPartitionEntries) {
5674 vd_efi_free(&edev, gpt, gpe);
5675 return (ESRCH);
5676 }
5677
5678 bcopy(&gpe[partno].efi_gpe_PartitionTypeGUID, &p64.p_type,
5679 sizeof (struct uuid));
5680 p64.p_start = gpe[partno].efi_gpe_StartingLBA;
5681 p64.p_size = gpe[partno].efi_gpe_EndingLBA - p64.p_start + 1;
5682
5683 if (ddi_copyout(&p64, arg, sizeof (struct partition64), flag)) {
5684 vd_efi_free(&edev, gpt, gpe);
5685 return (EFAULT);
5686 }
5687
5688 vd_efi_free(&edev, gpt, gpe);
5689 return (0);
5690 }
5691
5692 /*
5693 * Function:
5694 * vdc_dioctl_rwcmd()
5695 *
5696 * Description:
5697 * This function implements the DIOCTL_RWCMD ioctl. This ioctl is used
5698 * for DKC_DIRECT disks to read or write at an absolute disk offset.
5699 *
5700 * Arguments:
5701 * dev - device
5702 * arg - a pointer to a dadkio_rwcmd or dadkio_rwcmd32 structure
5703 * flag - ioctl flags
5704 */
5705 static int
5706 vdc_dioctl_rwcmd(vdc_t *vdc, caddr_t arg, int flag)
5707 {
5708 struct dadkio_rwcmd32 rwcmd32;
5709 struct dadkio_rwcmd rwcmd;
5710 struct iovec aiov;
5711 struct uio auio;
5712 int rw, status;
5713 struct buf *buf;
5714
5715 if (ddi_model_convert_from(flag & FMODELS) == DDI_MODEL_ILP32) {
5716 if (ddi_copyin((caddr_t)arg, (caddr_t)&rwcmd32,
5717 sizeof (struct dadkio_rwcmd32), flag)) {
5718 return (EFAULT);
5719 }
5720 rwcmd.cmd = rwcmd32.cmd;
5721 rwcmd.flags = rwcmd32.flags;
5722 rwcmd.blkaddr = (daddr_t)rwcmd32.blkaddr;
5723 rwcmd.buflen = rwcmd32.buflen;
5724 rwcmd.bufaddr = (caddr_t)(uintptr_t)rwcmd32.bufaddr;
5725 } else {
5726 if (ddi_copyin((caddr_t)arg, (caddr_t)&rwcmd,
5727 sizeof (struct dadkio_rwcmd), flag)) {
5728 return (EFAULT);
5729 }
5730 }
5731
5732 switch (rwcmd.cmd) {
5733 case DADKIO_RWCMD_READ:
5734 rw = B_READ;
5735 break;
5736 case DADKIO_RWCMD_WRITE:
5737 rw = B_WRITE;
5738 break;
5739 default:
5740 return (EINVAL);
5741 }
5742
5743 bzero((caddr_t)&aiov, sizeof (struct iovec));
5744 aiov.iov_base = rwcmd.bufaddr;
5745 aiov.iov_len = rwcmd.buflen;
5746
5747 bzero((caddr_t)&auio, sizeof (struct uio));
5748 auio.uio_iov = &aiov;
5749 auio.uio_iovcnt = 1;
5750 auio.uio_loffset = rwcmd.blkaddr * vdc->vdisk_bsize;
5751 auio.uio_resid = rwcmd.buflen;
5752 auio.uio_segflg = flag & FKIOCTL ? UIO_SYSSPACE : UIO_USERSPACE;
5753
5754 buf = kmem_alloc(sizeof (buf_t), KM_SLEEP);
5755 bioinit(buf);
5756 /*
5757 * We use the private field of buf to specify that this is an
5758 * I/O using an absolute offset.
5759 */
5760 buf->b_private = (void *)VD_SLICE_NONE;
5761
5762 status = physio(vdc_strategy, buf, VD_MAKE_DEV(vdc->instance, 0),
5763 rw, vdc_min, &auio);
5764
5765 biofini(buf);
5766 kmem_free(buf, sizeof (buf_t));
5767
5768 return (status);
5769 }
5770
5771 /*
5772 * Allocate a buffer for a VD_OP_SCSICMD operation. The size of the allocated
5773 * buffer is returned in alloc_len.
5774 */
5775 static vd_scsi_t *
5776 vdc_scsi_alloc(int cdb_len, int sense_len, int datain_len, int dataout_len,
5777 int *alloc_len)
5778 {
5779 vd_scsi_t *vd_scsi;
5780 int vd_scsi_len = VD_SCSI_SIZE;
5781
5782 vd_scsi_len += P2ROUNDUP(cdb_len, sizeof (uint64_t));
5783 vd_scsi_len += P2ROUNDUP(sense_len, sizeof (uint64_t));
5784 vd_scsi_len += P2ROUNDUP(datain_len, sizeof (uint64_t));
5785 vd_scsi_len += P2ROUNDUP(dataout_len, sizeof (uint64_t));
5786
5787 ASSERT(vd_scsi_len % sizeof (uint64_t) == 0);
5788
5789 vd_scsi = kmem_zalloc(vd_scsi_len, KM_SLEEP);
5790
5791 vd_scsi->cdb_len = cdb_len;
5792 vd_scsi->sense_len = sense_len;
5793 vd_scsi->datain_len = datain_len;
5794 vd_scsi->dataout_len = dataout_len;
5795
5796 *alloc_len = vd_scsi_len;
5797
5798 return (vd_scsi);
5799 }
5800
5801 /*
5802 * Convert the status of a SCSI command to a Solaris return code.
5803 *
5804 * Arguments:
5805 * vd_scsi - The SCSI operation buffer.
5806 * log_error - indicate if an error message should be logged.
5807 *
5808 * Note that our SCSI error messages are rather primitive for the moment
5809 * and could be improved by decoding some data like the SCSI command and
5810 * the sense key.
5811 *
5812 * Return value:
5813 * 0 - Status is good.
5814 * EACCES - Status reports a reservation conflict.
5815 * ENOTSUP - Status reports a check condition and sense key
5816 * reports an illegal request.
5817 * EIO - Any other status.
5818 */
5819 static int
5820 vdc_scsi_status(vdc_t *vdc, vd_scsi_t *vd_scsi, boolean_t log_error)
5821 {
5822 int rv;
5823 char path_str[MAXPATHLEN];
5824 char panic_str[VDC_RESV_CONFLICT_FMT_LEN + MAXPATHLEN];
5825 union scsi_cdb *cdb;
5826 struct scsi_extended_sense *sense;
5827
5828 if (vd_scsi->cmd_status == STATUS_GOOD)
5829 /* no error */
5830 return (0);
5831
5832 /* when the tunable vdc_scsi_log_error is true we log all errors */
5833 if (vdc_scsi_log_error)
5834 log_error = B_TRUE;
5835
5836 if (log_error) {
5837 cmn_err(CE_WARN, "%s (vdc%d):\tError for Command: 0x%x)\n",
5838 ddi_pathname(vdc->dip, path_str), vdc->instance,
5839 GETCMD(VD_SCSI_DATA_CDB(vd_scsi)));
5840 }
5841
5842 /* default returned value */
5843 rv = EIO;
5844
5845 switch (vd_scsi->cmd_status) {
5846
5847 case STATUS_CHECK:
5848 case STATUS_TERMINATED:
5849 if (log_error)
5850 cmn_err(CE_CONT, "\tCheck Condition Error\n");
5851
5852 /* check sense buffer */
5853 if (vd_scsi->sense_len == 0 ||
5854 vd_scsi->sense_status != STATUS_GOOD) {
5855 if (log_error)
5856 cmn_err(CE_CONT, "\tNo Sense Data Available\n");
5857 break;
5858 }
5859
5860 sense = VD_SCSI_DATA_SENSE(vd_scsi);
5861
5862 if (log_error) {
5863 cmn_err(CE_CONT, "\tSense Key: 0x%x\n"
5864 "\tASC: 0x%x, ASCQ: 0x%x\n",
5865 scsi_sense_key((uint8_t *)sense),
5866 scsi_sense_asc((uint8_t *)sense),
5867 scsi_sense_ascq((uint8_t *)sense));
5868 }
5869
5870 if (scsi_sense_key((uint8_t *)sense) == KEY_ILLEGAL_REQUEST)
5871 rv = ENOTSUP;
5872 break;
5873
5874 case STATUS_BUSY:
5875 if (log_error)
5876 cmn_err(CE_NOTE, "\tDevice Busy\n");
5877 break;
5878
5879 case STATUS_RESERVATION_CONFLICT:
5880 /*
5881 * If the command was PERSISTENT_RESERVATION_[IN|OUT] then
5882 * reservation conflict could be due to various reasons like
5883 * incorrect keys, not registered or not reserved etc. So,
5884 * we should not panic in that case.
5885 */
5886 cdb = VD_SCSI_DATA_CDB(vd_scsi);
5887 if (vdc->failfast_interval != 0 &&
5888 cdb->scc_cmd != SCMD_PERSISTENT_RESERVE_IN &&
5889 cdb->scc_cmd != SCMD_PERSISTENT_RESERVE_OUT) {
5890 /* failfast is enabled so we have to panic */
5891 (void) snprintf(panic_str, sizeof (panic_str),
5892 VDC_RESV_CONFLICT_FMT_STR "%s",
5893 ddi_pathname(vdc->dip, path_str));
5894 panic(panic_str);
5895 }
5896 if (log_error)
5897 cmn_err(CE_NOTE, "\tReservation Conflict\n");
5898 rv = EACCES;
5899 break;
5900
5901 case STATUS_QFULL:
5902 if (log_error)
5903 cmn_err(CE_NOTE, "\tQueue Full\n");
5904 break;
5905
5906 case STATUS_MET:
5907 case STATUS_INTERMEDIATE:
5908 case STATUS_SCSI2:
5909 case STATUS_INTERMEDIATE_MET:
5910 case STATUS_ACA_ACTIVE:
5911 if (log_error)
5912 cmn_err(CE_CONT,
5913 "\tUnexpected SCSI status received: 0x%x\n",
5914 vd_scsi->cmd_status);
5915 break;
5916
5917 default:
5918 if (log_error)
5919 cmn_err(CE_CONT,
5920 "\tInvalid SCSI status received: 0x%x\n",
5921 vd_scsi->cmd_status);
5922 break;
5923 }
5924
5925 return (rv);
5926 }
5927
5928 /*
5929 * Implemented the USCSICMD uscsi(7I) ioctl. This ioctl is converted to
5930 * a VD_OP_SCSICMD operation which is sent to the vdisk server. If a SCSI
5931 * reset is requested (i.e. a flag USCSI_RESET* is set) then the ioctl is
5932 * converted to a VD_OP_RESET operation.
5933 */
5934 static int
5935 vdc_uscsi_cmd(vdc_t *vdc, caddr_t arg, int mode)
5936 {
5937 struct uscsi_cmd uscsi;
5938 struct uscsi_cmd32 uscsi32;
5939 vd_scsi_t *vd_scsi;
5940 int vd_scsi_len;
5941 union scsi_cdb *cdb;
5942 struct scsi_extended_sense *sense;
5943 char *datain, *dataout;
5944 size_t cdb_len, datain_len, dataout_len, sense_len;
5945 int rv;
5946
5947 if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
5948 if (ddi_copyin(arg, &uscsi32, sizeof (struct uscsi_cmd32),
5949 mode) != 0)
5950 return (EFAULT);
5951 uscsi_cmd32touscsi_cmd((&uscsi32), (&uscsi));
5952 } else {
5953 if (ddi_copyin(arg, &uscsi, sizeof (struct uscsi_cmd),
5954 mode) != 0)
5955 return (EFAULT);
5956 }
5957
5958 /* a uscsi reset is converted to a VD_OP_RESET operation */
5959 if (uscsi.uscsi_flags & (USCSI_RESET | USCSI_RESET_LUN |
5960 USCSI_RESET_ALL)) {
5961 rv = vdc_do_sync_op(vdc, VD_OP_RESET, NULL, 0, 0, 0,
5962 VIO_both_dir, B_TRUE);
5963 return (rv);
5964 }
5965
5966 /* cdb buffer length */
5967 cdb_len = uscsi.uscsi_cdblen;
5968
5969 /* data in and out buffers length */
5970 if (uscsi.uscsi_flags & USCSI_READ) {
5971 datain_len = uscsi.uscsi_buflen;
5972 dataout_len = 0;
5973 } else {
5974 datain_len = 0;
5975 dataout_len = uscsi.uscsi_buflen;
5976 }
5977
5978 /* sense buffer length */
5979 if (uscsi.uscsi_flags & USCSI_RQENABLE)
5980 sense_len = uscsi.uscsi_rqlen;
5981 else
5982 sense_len = 0;
5983
5984 /* allocate buffer for the VD_SCSICMD_OP operation */
5985 vd_scsi = vdc_scsi_alloc(cdb_len, sense_len, datain_len, dataout_len,
5986 &vd_scsi_len);
5987
5988 /*
5989 * The documentation of USCSI_ISOLATE and USCSI_DIAGNOSE is very vague,
5990 * but basically they prevent a SCSI command from being retried in case
5991 * of an error.
5992 */
5993 if ((uscsi.uscsi_flags & USCSI_ISOLATE) ||
5994 (uscsi.uscsi_flags & USCSI_DIAGNOSE))
5995 vd_scsi->options |= VD_SCSI_OPT_NORETRY;
5996
5997 /* set task attribute */
5998 if (uscsi.uscsi_flags & USCSI_NOTAG) {
5999 vd_scsi->task_attribute = 0;
6000 } else {
6001 if (uscsi.uscsi_flags & USCSI_HEAD)
6002 vd_scsi->task_attribute = VD_SCSI_TASK_ACA;
6003 else if (uscsi.uscsi_flags & USCSI_HTAG)
6004 vd_scsi->task_attribute = VD_SCSI_TASK_HQUEUE;
6005 else if (uscsi.uscsi_flags & USCSI_OTAG)
6006 vd_scsi->task_attribute = VD_SCSI_TASK_ORDERED;
6007 else
6008 vd_scsi->task_attribute = 0;
6009 }
6010
6011 /* set timeout */
6012 vd_scsi->timeout = uscsi.uscsi_timeout;
6013
6014 /* copy-in cdb data */
6015 cdb = VD_SCSI_DATA_CDB(vd_scsi);
6016 if (ddi_copyin(uscsi.uscsi_cdb, cdb, cdb_len, mode) != 0) {
6017 rv = EFAULT;
6018 goto done;
6019 }
6020
6021 /* keep a pointer to the sense buffer */
6022 sense = VD_SCSI_DATA_SENSE(vd_scsi);
6023
6024 /* keep a pointer to the data-in buffer */
6025 datain = (char *)VD_SCSI_DATA_IN(vd_scsi);
6026
6027 /* copy-in request data to the data-out buffer */
6028 dataout = (char *)VD_SCSI_DATA_OUT(vd_scsi);
6029 if (!(uscsi.uscsi_flags & USCSI_READ)) {
6030 if (ddi_copyin(uscsi.uscsi_bufaddr, dataout, dataout_len,
6031 mode)) {
6032 rv = EFAULT;
6033 goto done;
6034 }
6035 }
6036
6037 /* submit the request */
6038 rv = vdc_do_sync_op(vdc, VD_OP_SCSICMD, (caddr_t)vd_scsi, vd_scsi_len,
6039 0, 0, VIO_both_dir, B_FALSE);
6040
6041 if (rv != 0)
6042 goto done;
6043
6044 /* update scsi status */
6045 uscsi.uscsi_status = vd_scsi->cmd_status;
6046
6047 /* update sense data */
6048 if ((uscsi.uscsi_flags & USCSI_RQENABLE) &&
6049 (uscsi.uscsi_status == STATUS_CHECK ||
6050 uscsi.uscsi_status == STATUS_TERMINATED)) {
6051
6052 uscsi.uscsi_rqstatus = vd_scsi->sense_status;
6053
6054 if (uscsi.uscsi_rqstatus == STATUS_GOOD) {
6055 uscsi.uscsi_rqresid = uscsi.uscsi_rqlen -
6056 vd_scsi->sense_len;
6057 if (ddi_copyout(sense, uscsi.uscsi_rqbuf,
6058 vd_scsi->sense_len, mode) != 0) {
6059 rv = EFAULT;
6060 goto done;
6061 }
6062 }
6063 }
6064
6065 /* update request data */
6066 if (uscsi.uscsi_status == STATUS_GOOD) {
6067 if (uscsi.uscsi_flags & USCSI_READ) {
6068 uscsi.uscsi_resid = uscsi.uscsi_buflen -
6069 vd_scsi->datain_len;
6070 if (ddi_copyout(datain, uscsi.uscsi_bufaddr,
6071 vd_scsi->datain_len, mode) != 0) {
6072 rv = EFAULT;
6073 goto done;
6074 }
6075 } else {
6076 uscsi.uscsi_resid = uscsi.uscsi_buflen -
6077 vd_scsi->dataout_len;
6078 }
6079 }
6080
6081 /* copy-out result */
6082 if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
6083 uscsi_cmdtouscsi_cmd32((&uscsi), (&uscsi32));
6084 if (ddi_copyout(&uscsi32, arg, sizeof (struct uscsi_cmd32),
6085 mode) != 0) {
6086 rv = EFAULT;
6087 goto done;
6088 }
6089 } else {
6090 if (ddi_copyout(&uscsi, arg, sizeof (struct uscsi_cmd),
6091 mode) != 0) {
6092 rv = EFAULT;
6093 goto done;
6094 }
6095 }
6096
6097 /* get the return code from the SCSI command status */
6098 rv = vdc_scsi_status(vdc, vd_scsi,
6099 !(uscsi.uscsi_flags & USCSI_SILENT));
6100
6101 done:
6102 kmem_free(vd_scsi, vd_scsi_len);
6103 return (rv);
6104 }
6105
6106 /*
6107 * Create a VD_OP_SCSICMD buffer for a SCSI PERSISTENT IN command.
6108 *
6109 * Arguments:
6110 * cmd - SCSI PERSISTENT IN command
6111 * len - length of the SCSI input buffer
6112 * vd_scsi_len - return the length of the allocated buffer
6113 *
6114 * Returned Value:
6115 * a pointer to the allocated VD_OP_SCSICMD buffer.
6116 */
6117 static vd_scsi_t *
6118 vdc_scsi_alloc_persistent_in(uchar_t cmd, int len, int *vd_scsi_len)
6119 {
6120 int cdb_len, sense_len, datain_len, dataout_len;
6121 vd_scsi_t *vd_scsi;
6122 union scsi_cdb *cdb;
6123
6124 cdb_len = CDB_GROUP1;
6125 sense_len = sizeof (struct scsi_extended_sense);
6126 datain_len = len;
6127 dataout_len = 0;
6128
6129 vd_scsi = vdc_scsi_alloc(cdb_len, sense_len, datain_len, dataout_len,
6130 vd_scsi_len);
6131
6132 cdb = VD_SCSI_DATA_CDB(vd_scsi);
6133
6134 /* set cdb */
6135 cdb->scc_cmd = SCMD_PERSISTENT_RESERVE_IN;
6136 cdb->cdb_opaque[1] = cmd;
6137 FORMG1COUNT(cdb, datain_len);
6138
6139 vd_scsi->timeout = vdc_scsi_timeout;
6140
6141 return (vd_scsi);
6142 }
6143
6144 /*
6145 * Create a VD_OP_SCSICMD buffer for a SCSI PERSISTENT OUT command.
6146 *
6147 * Arguments:
6148 * cmd - SCSI PERSISTENT OUT command
6149 * len - length of the SCSI output buffer
6150 * vd_scsi_len - return the length of the allocated buffer
6151 *
6152 * Returned Code:
6153 * a pointer to the allocated VD_OP_SCSICMD buffer.
6154 */
6155 static vd_scsi_t *
6156 vdc_scsi_alloc_persistent_out(uchar_t cmd, int len, int *vd_scsi_len)
6157 {
6158 int cdb_len, sense_len, datain_len, dataout_len;
6159 vd_scsi_t *vd_scsi;
6160 union scsi_cdb *cdb;
6161
6162 cdb_len = CDB_GROUP1;
6163 sense_len = sizeof (struct scsi_extended_sense);
6164 datain_len = 0;
6165 dataout_len = len;
6166
6167 vd_scsi = vdc_scsi_alloc(cdb_len, sense_len, datain_len, dataout_len,
6168 vd_scsi_len);
6169
6170 cdb = VD_SCSI_DATA_CDB(vd_scsi);
6171
6172 /* set cdb */
6173 cdb->scc_cmd = SCMD_PERSISTENT_RESERVE_OUT;
6174 cdb->cdb_opaque[1] = cmd;
6175 FORMG1COUNT(cdb, dataout_len);
6176
6177 vd_scsi->timeout = vdc_scsi_timeout;
6178
6179 return (vd_scsi);
6180 }
6181
6182 /*
6183 * Implement the MHIOCGRP_INKEYS mhd(7i) ioctl. The ioctl is converted
6184 * to a SCSI PERSISTENT IN READ KEYS command which is sent to the vdisk
6185 * server with a VD_OP_SCSICMD operation.
6186 */
6187 static int
6188 vdc_mhd_inkeys(vdc_t *vdc, caddr_t arg, int mode)
6189 {
6190 vd_scsi_t *vd_scsi;
6191 mhioc_inkeys_t inkeys;
6192 mhioc_key_list_t klist;
6193 struct mhioc_inkeys32 inkeys32;
6194 struct mhioc_key_list32 klist32;
6195 sd_prin_readkeys_t *scsi_keys;
6196 void *user_keys;
6197 int vd_scsi_len;
6198 int listsize, listlen, rv;
6199
6200 /* copyin arguments */
6201 if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
6202 rv = ddi_copyin(arg, &inkeys32, sizeof (inkeys32), mode);
6203 if (rv != 0)
6204 return (EFAULT);
6205
6206 rv = ddi_copyin((caddr_t)(uintptr_t)inkeys32.li, &klist32,
6207 sizeof (klist32), mode);
6208 if (rv != 0)
6209 return (EFAULT);
6210
6211 listsize = klist32.listsize;
6212 } else {
6213 rv = ddi_copyin(arg, &inkeys, sizeof (inkeys), mode);
6214 if (rv != 0)
6215 return (EFAULT);
6216
6217 rv = ddi_copyin(inkeys.li, &klist, sizeof (klist), mode);
6218 if (rv != 0)
6219 return (EFAULT);
6220
6221 listsize = klist.listsize;
6222 }
6223
6224 /* build SCSI VD_OP request */
6225 vd_scsi = vdc_scsi_alloc_persistent_in(SD_READ_KEYS,
6226 sizeof (sd_prin_readkeys_t) - sizeof (caddr_t) +
6227 (sizeof (mhioc_resv_key_t) * listsize), &vd_scsi_len);
6228
6229 scsi_keys = (sd_prin_readkeys_t *)VD_SCSI_DATA_IN(vd_scsi);
6230
6231 /* submit the request */
6232 rv = vdc_do_sync_op(vdc, VD_OP_SCSICMD, (caddr_t)vd_scsi, vd_scsi_len,
6233 0, 0, VIO_both_dir, B_FALSE);
6234
6235 if (rv != 0)
6236 goto done;
6237
6238 listlen = scsi_keys->len / MHIOC_RESV_KEY_SIZE;
6239
6240 if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
6241 inkeys32.generation = scsi_keys->generation;
6242 rv = ddi_copyout(&inkeys32, arg, sizeof (inkeys32), mode);
6243 if (rv != 0) {
6244 rv = EFAULT;
6245 goto done;
6246 }
6247
6248 klist32.listlen = listlen;
6249 rv = ddi_copyout(&klist32, (caddr_t)(uintptr_t)inkeys32.li,
6250 sizeof (klist32), mode);
6251 if (rv != 0) {
6252 rv = EFAULT;
6253 goto done;
6254 }
6255
6256 user_keys = (caddr_t)(uintptr_t)klist32.list;
6257 } else {
6258 inkeys.generation = scsi_keys->generation;
6259 rv = ddi_copyout(&inkeys, arg, sizeof (inkeys), mode);
6260 if (rv != 0) {
6261 rv = EFAULT;
6262 goto done;
6263 }
6264
6265 klist.listlen = listlen;
6266 rv = ddi_copyout(&klist, inkeys.li, sizeof (klist), mode);
6267 if (rv != 0) {
6268 rv = EFAULT;
6269 goto done;
6270 }
6271
6272 user_keys = klist.list;
6273 }
6274
6275 /* copy out keys */
6276 if (listlen > 0 && listsize > 0) {
6277 if (listsize < listlen)
6278 listlen = listsize;
6279 rv = ddi_copyout(&scsi_keys->keylist, user_keys,
6280 listlen * MHIOC_RESV_KEY_SIZE, mode);
6281 if (rv != 0)
6282 rv = EFAULT;
6283 }
6284
6285 if (rv == 0)
6286 rv = vdc_scsi_status(vdc, vd_scsi, B_FALSE);
6287
6288 done:
6289 kmem_free(vd_scsi, vd_scsi_len);
6290
6291 return (rv);
6292 }
6293
6294 /*
6295 * Implement the MHIOCGRP_INRESV mhd(7i) ioctl. The ioctl is converted
6296 * to a SCSI PERSISTENT IN READ RESERVATION command which is sent to
6297 * the vdisk server with a VD_OP_SCSICMD operation.
6298 */
6299 static int
6300 vdc_mhd_inresv(vdc_t *vdc, caddr_t arg, int mode)
6301 {
6302 vd_scsi_t *vd_scsi;
6303 mhioc_inresvs_t inresv;
6304 mhioc_resv_desc_list_t rlist;
6305 struct mhioc_inresvs32 inresv32;
6306 struct mhioc_resv_desc_list32 rlist32;
6307 mhioc_resv_desc_t mhd_resv;
6308 sd_prin_readresv_t *scsi_resv;
6309 sd_readresv_desc_t *resv;
6310 mhioc_resv_desc_t *user_resv;
6311 int vd_scsi_len;
6312 int listsize, listlen, i, rv;
6313
6314 /* copyin arguments */
6315 if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
6316 rv = ddi_copyin(arg, &inresv32, sizeof (inresv32), mode);
6317 if (rv != 0)
6318 return (EFAULT);
6319
6320 rv = ddi_copyin((caddr_t)(uintptr_t)inresv32.li, &rlist32,
6321 sizeof (rlist32), mode);
6322 if (rv != 0)
6323 return (EFAULT);
6324
6325 listsize = rlist32.listsize;
6326 } else {
6327 rv = ddi_copyin(arg, &inresv, sizeof (inresv), mode);
6328 if (rv != 0)
6329 return (EFAULT);
6330
6331 rv = ddi_copyin(inresv.li, &rlist, sizeof (rlist), mode);
6332 if (rv != 0)
6333 return (EFAULT);
6334
6335 listsize = rlist.listsize;
6336 }
6337
6338 /* build SCSI VD_OP request */
6339 vd_scsi = vdc_scsi_alloc_persistent_in(SD_READ_RESV,
6340 sizeof (sd_prin_readresv_t) - sizeof (caddr_t) +
6341 (SCSI3_RESV_DESC_LEN * listsize), &vd_scsi_len);
6342
6343 scsi_resv = (sd_prin_readresv_t *)VD_SCSI_DATA_IN(vd_scsi);
6344
6345 /* submit the request */
6346 rv = vdc_do_sync_op(vdc, VD_OP_SCSICMD, (caddr_t)vd_scsi, vd_scsi_len,
6347 0, 0, VIO_both_dir, B_FALSE);
6348
6349 if (rv != 0)
6350 goto done;
6351
6352 listlen = scsi_resv->len / SCSI3_RESV_DESC_LEN;
6353
6354 if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
6355 inresv32.generation = scsi_resv->generation;
6356 rv = ddi_copyout(&inresv32, arg, sizeof (inresv32), mode);
6357 if (rv != 0) {
6358 rv = EFAULT;
6359 goto done;
6360 }
6361
6362 rlist32.listlen = listlen;
6363 rv = ddi_copyout(&rlist32, (caddr_t)(uintptr_t)inresv32.li,
6364 sizeof (rlist32), mode);
6365 if (rv != 0) {
6366 rv = EFAULT;
6367 goto done;
6368 }
6369
6370 user_resv = (mhioc_resv_desc_t *)(uintptr_t)rlist32.list;
6371 } else {
6372 inresv.generation = scsi_resv->generation;
6373 rv = ddi_copyout(&inresv, arg, sizeof (inresv), mode);
6374 if (rv != 0) {
6375 rv = EFAULT;
6376 goto done;
6377 }
6378
6379 rlist.listlen = listlen;
6380 rv = ddi_copyout(&rlist, inresv.li, sizeof (rlist), mode);
6381 if (rv != 0) {
6382 rv = EFAULT;
6383 goto done;
6384 }
6385
6386 user_resv = rlist.list;
6387 }
6388
6389 /* copy out reservations */
6390 if (listsize > 0 && listlen > 0) {
6391 if (listsize < listlen)
6392 listlen = listsize;
6393 resv = (sd_readresv_desc_t *)&scsi_resv->readresv_desc;
6394
6395 for (i = 0; i < listlen; i++) {
6396 mhd_resv.type = resv->type;
6397 mhd_resv.scope = resv->scope;
6398 mhd_resv.scope_specific_addr =
6399 BE_32(resv->scope_specific_addr);
6400 bcopy(&resv->resvkey, &mhd_resv.key,
6401 MHIOC_RESV_KEY_SIZE);
6402
6403 rv = ddi_copyout(&mhd_resv, user_resv,
6404 sizeof (mhd_resv), mode);
6405 if (rv != 0) {
6406 rv = EFAULT;
6407 goto done;
6408 }
6409 resv++;
6410 user_resv++;
6411 }
6412 }
6413
6414 if (rv == 0)
6415 rv = vdc_scsi_status(vdc, vd_scsi, B_FALSE);
6416
6417 done:
6418 kmem_free(vd_scsi, vd_scsi_len);
6419 return (rv);
6420 }
6421
6422 /*
6423 * Implement the MHIOCGRP_REGISTER mhd(7i) ioctl. The ioctl is converted
6424 * to a SCSI PERSISTENT OUT REGISTER command which is sent to the vdisk
6425 * server with a VD_OP_SCSICMD operation.
6426 */
6427 static int
6428 vdc_mhd_register(vdc_t *vdc, caddr_t arg, int mode)
6429 {
6430 vd_scsi_t *vd_scsi;
6431 sd_prout_t *scsi_prout;
6432 mhioc_register_t mhd_reg;
6433 int vd_scsi_len, rv;
6434
6435 /* copyin arguments */
6436 rv = ddi_copyin(arg, &mhd_reg, sizeof (mhd_reg), mode);
6437 if (rv != 0)
6438 return (EFAULT);
6439
6440 /* build SCSI VD_OP request */
6441 vd_scsi = vdc_scsi_alloc_persistent_out(SD_SCSI3_REGISTER,
6442 sizeof (sd_prout_t), &vd_scsi_len);
6443
6444 /* set parameters */
6445 scsi_prout = (sd_prout_t *)VD_SCSI_DATA_OUT(vd_scsi);
6446 bcopy(mhd_reg.oldkey.key, scsi_prout->res_key, MHIOC_RESV_KEY_SIZE);
6447 bcopy(mhd_reg.newkey.key, scsi_prout->service_key, MHIOC_RESV_KEY_SIZE);
6448 scsi_prout->aptpl = (uchar_t)mhd_reg.aptpl;
6449
6450 /* submit the request */
6451 rv = vdc_do_sync_op(vdc, VD_OP_SCSICMD, (caddr_t)vd_scsi, vd_scsi_len,
6452 0, 0, VIO_both_dir, B_FALSE);
6453
6454 if (rv == 0)
6455 rv = vdc_scsi_status(vdc, vd_scsi, B_FALSE);
6456
6457 kmem_free(vd_scsi, vd_scsi_len);
6458 return (rv);
6459 }
6460
6461 /*
6462 * Implement the MHIOCGRP_RESERVE mhd(7i) ioctl. The ioctl is converted
6463 * to a SCSI PERSISTENT OUT RESERVE command which is sent to the vdisk
6464 * server with a VD_OP_SCSICMD operation.
6465 */
6466 static int
6467 vdc_mhd_reserve(vdc_t *vdc, caddr_t arg, int mode)
6468 {
6469 union scsi_cdb *cdb;
6470 vd_scsi_t *vd_scsi;
6471 sd_prout_t *scsi_prout;
6472 mhioc_resv_desc_t mhd_resv;
6473 int vd_scsi_len, rv;
6474
6475 /* copyin arguments */
6476 rv = ddi_copyin(arg, &mhd_resv, sizeof (mhd_resv), mode);
6477 if (rv != 0)
6478 return (EFAULT);
6479
6480 /* build SCSI VD_OP request */
6481 vd_scsi = vdc_scsi_alloc_persistent_out(SD_SCSI3_RESERVE,
6482 sizeof (sd_prout_t), &vd_scsi_len);
6483
6484 /* set parameters */
6485 cdb = VD_SCSI_DATA_CDB(vd_scsi);
6486 scsi_prout = (sd_prout_t *)VD_SCSI_DATA_OUT(vd_scsi);
6487 bcopy(mhd_resv.key.key, scsi_prout->res_key, MHIOC_RESV_KEY_SIZE);
6488 scsi_prout->scope_address = mhd_resv.scope_specific_addr;
6489 cdb->cdb_opaque[2] = mhd_resv.type;
6490
6491 /* submit the request */
6492 rv = vdc_do_sync_op(vdc, VD_OP_SCSICMD, (caddr_t)vd_scsi, vd_scsi_len,
6493 0, 0, VIO_both_dir, B_FALSE);
6494
6495 if (rv == 0)
6496 rv = vdc_scsi_status(vdc, vd_scsi, B_FALSE);
6497
6498 kmem_free(vd_scsi, vd_scsi_len);
6499 return (rv);
6500 }
6501
6502 /*
6503 * Implement the MHIOCGRP_PREEMPTANDABORT mhd(7i) ioctl. The ioctl is
6504 * converted to a SCSI PERSISTENT OUT PREEMPT AND ABORT command which
6505 * is sent to the vdisk server with a VD_OP_SCSICMD operation.
6506 */
6507 static int
6508 vdc_mhd_preemptabort(vdc_t *vdc, caddr_t arg, int mode)
6509 {
6510 union scsi_cdb *cdb;
6511 vd_scsi_t *vd_scsi;
6512 sd_prout_t *scsi_prout;
6513 mhioc_preemptandabort_t mhd_preempt;
6514 int vd_scsi_len, rv;
6515
6516 /* copyin arguments */
6517 rv = ddi_copyin(arg, &mhd_preempt, sizeof (mhd_preempt), mode);
6518 if (rv != 0)
6519 return (EFAULT);
6520
6521 /* build SCSI VD_OP request */
6522 vd_scsi = vdc_scsi_alloc_persistent_out(SD_SCSI3_PREEMPTANDABORT,
6523 sizeof (sd_prout_t), &vd_scsi_len);
6524
6525 /* set parameters */
6526 vd_scsi->task_attribute = VD_SCSI_TASK_ACA;
6527 cdb = VD_SCSI_DATA_CDB(vd_scsi);
6528 scsi_prout = (sd_prout_t *)VD_SCSI_DATA_OUT(vd_scsi);
6529 bcopy(mhd_preempt.resvdesc.key.key, scsi_prout->res_key,
6530 MHIOC_RESV_KEY_SIZE);
6531 bcopy(mhd_preempt.victim_key.key, scsi_prout->service_key,
6532 MHIOC_RESV_KEY_SIZE);
6533 scsi_prout->scope_address = mhd_preempt.resvdesc.scope_specific_addr;
6534 cdb->cdb_opaque[2] = mhd_preempt.resvdesc.type;
6535
6536 /* submit the request */
6537 rv = vdc_do_sync_op(vdc, VD_OP_SCSICMD, (caddr_t)vd_scsi, vd_scsi_len,
6538 0, 0, VIO_both_dir, B_FALSE);
6539
6540 if (rv == 0)
6541 rv = vdc_scsi_status(vdc, vd_scsi, B_FALSE);
6542
6543 kmem_free(vd_scsi, vd_scsi_len);
6544 return (rv);
6545 }
6546
6547 /*
6548 * Implement the MHIOCGRP_REGISTERANDIGNOREKEY mhd(7i) ioctl. The ioctl
6549 * is converted to a SCSI PERSISTENT OUT REGISTER AND IGNORE EXISTING KEY
6550 * command which is sent to the vdisk server with a VD_OP_SCSICMD operation.
6551 */
6552 static int
6553 vdc_mhd_registerignore(vdc_t *vdc, caddr_t arg, int mode)
6554 {
6555 vd_scsi_t *vd_scsi;
6556 sd_prout_t *scsi_prout;
6557 mhioc_registerandignorekey_t mhd_regi;
6558 int vd_scsi_len, rv;
6559
6560 /* copyin arguments */
6561 rv = ddi_copyin(arg, &mhd_regi, sizeof (mhd_regi), mode);
6562 if (rv != 0)
6563 return (EFAULT);
6564
6565 /* build SCSI VD_OP request */
6566 vd_scsi = vdc_scsi_alloc_persistent_out(SD_SCSI3_REGISTERANDIGNOREKEY,
6567 sizeof (sd_prout_t), &vd_scsi_len);
6568
6569 /* set parameters */
6570 scsi_prout = (sd_prout_t *)VD_SCSI_DATA_OUT(vd_scsi);
6571 bcopy(mhd_regi.newkey.key, scsi_prout->service_key,
6572 MHIOC_RESV_KEY_SIZE);
6573 scsi_prout->aptpl = (uchar_t)mhd_regi.aptpl;
6574
6575 /* submit the request */
6576 rv = vdc_do_sync_op(vdc, VD_OP_SCSICMD, (caddr_t)vd_scsi, vd_scsi_len,
6577 0, 0, VIO_both_dir, B_FALSE);
6578
6579 if (rv == 0)
6580 rv = vdc_scsi_status(vdc, vd_scsi, B_FALSE);
6581
6582 kmem_free(vd_scsi, vd_scsi_len);
6583 return (rv);
6584 }
6585
6586 /*
6587 * This function is used to send a (simple) SCSI command and check errors.
6588 */
6589 static int
6590 vdc_eio_scsi_cmd(vdc_t *vdc, uchar_t scmd, int flags)
6591 {
6592 int cdb_len, sense_len, vd_scsi_len;
6593 vd_scsi_t *vd_scsi;
6594 union scsi_cdb *cdb;
6595 int rv;
6596
6597 ASSERT(scmd == SCMD_TEST_UNIT_READY || scmd == SCMD_WRITE_G1);
6598
6599 if (scmd == SCMD_WRITE_G1)
6600 cdb_len = CDB_GROUP1;
6601 else
6602 cdb_len = CDB_GROUP0;
6603
6604 sense_len = sizeof (struct scsi_extended_sense);
6605
6606 vd_scsi = vdc_scsi_alloc(cdb_len, sense_len, 0, 0, &vd_scsi_len);
6607
6608 /* set cdb */
6609 cdb = VD_SCSI_DATA_CDB(vd_scsi);
6610 cdb->scc_cmd = scmd;
6611
6612 vd_scsi->timeout = vdc_scsi_timeout;
6613
6614 /*
6615 * Submit the request. Note the operation should not request that any
6616 * error is checked because this function is precisely called when
6617 * checking errors.
6618 */
6619 ASSERT((flags & VDC_OP_ERRCHK) == 0);
6620
6621 rv = vdc_do_op(vdc, VD_OP_SCSICMD, (caddr_t)vd_scsi, vd_scsi_len,
6622 0, 0, NULL, VIO_both_dir, flags);
6623
6624 if (rv == 0)
6625 rv = vdc_scsi_status(vdc, vd_scsi, B_FALSE);
6626
6627 kmem_free(vd_scsi, vd_scsi_len);
6628 return (rv);
6629 }
6630
6631 /*
6632 * This function is used to check if a SCSI backend is accessible. It will
6633 * also detect reservation conflict if failfast is enabled, and panic the
6634 * system in that case.
6635 *
6636 * Returned Code:
6637 * 0 - disk is accessible
6638 * != 0 - disk is inaccessible or unable to check if disk is accessible
6639 */
6640 static int
6641 vdc_eio_scsi_check(vdc_t *vdc, int flags)
6642 {
6643 int failure = 0;
6644 int rv;
6645
6646 /*
6647 * Send a TEST UNIT READY command. The command will panic
6648 * the system if it fails with a reservation conflict and
6649 * failfast is enabled. If there is a reservation conflict
6650 * and failfast is not enabled then the function will return
6651 * EACCES. In that case, there's no problem with accessing
6652 * the backend, it is just reserved.
6653 */
6654 rv = vdc_eio_scsi_cmd(vdc, SCMD_TEST_UNIT_READY, flags);
6655 if (rv != 0 && rv != EACCES)
6656 failure++;
6657
6658 /* we don't need to do more checking if failfast is not enabled */
6659 if (vdc->failfast_interval == 0)
6660 return (failure);
6661
6662 /*
6663 * With SPC-3 compliant devices TEST UNIT READY will succeed on
6664 * a reserved device, so we also do a WRITE(10) of zero byte in
6665 * order to provoke a Reservation Conflict status on those newer
6666 * devices.
6667 */
6668 if (vdc_eio_scsi_cmd(vdc, SCMD_WRITE_G1, flags) != 0)
6669 failure++;
6670
6671 return (failure);
6672 }
6673
6674 /*
6675 * This function is used to check if a backend is effectively accessible.
6676 *
6677 * Returned Code:
6678 * 0 - disk is accessible
6679 * != 0 - disk is inaccessible or unable to check if disk is accessible
6680 */
6681 static int
6682 vdc_eio_check(vdc_t *vdc, int flags)
6683 {
6684 char *buffer;
6685 diskaddr_t blkno;
6686 int rv;
6687
6688 ASSERT((flags & VDC_OP_ERRCHK) == 0);
6689
6690 flags |= VDC_OP_DRING_RESERVED;
6691
6692 if (VD_OP_SUPPORTED(vdc->operations, VD_OP_SCSICMD))
6693 return (vdc_eio_scsi_check(vdc, flags));
6694
6695 ASSERT(vdc->failfast_interval == 0);
6696
6697 /*
6698 * If the backend does not support SCSI operations then we simply
6699 * check if the backend is accessible by reading some data blocks.
6700 * We first try to read a random block, to try to avoid getting
6701 * a block that might have been cached on the service domain. Then
6702 * we try the last block, and finally the first block.
6703 *
6704 * We return success as soon as we are able to read any block.
6705 */
6706 buffer = kmem_alloc(vdc->vdisk_bsize, KM_SLEEP);
6707
6708 if (vdc->vdisk_size > 0) {
6709
6710 /* try a random block */
6711 (void) random_get_pseudo_bytes((uint8_t *)&blkno,
6712 sizeof (diskaddr_t));
6713 blkno = blkno % vdc->vdisk_size;
6714 rv = vdc_do_op(vdc, VD_OP_BREAD, (caddr_t)buffer,
6715 vdc->vdisk_bsize, VD_SLICE_NONE, blkno, NULL,
6716 VIO_read_dir, flags);
6717
6718 if (rv == 0)
6719 goto done;
6720
6721 /* try the last block */
6722 blkno = vdc->vdisk_size - 1;
6723 rv = vdc_do_op(vdc, VD_OP_BREAD, (caddr_t)buffer,
6724 vdc->vdisk_bsize, VD_SLICE_NONE, blkno, NULL,
6725 VIO_read_dir, flags);
6726
6727 if (rv == 0)
6728 goto done;
6729 }
6730
6731 /* try block 0 */
6732 blkno = 0;
6733 rv = vdc_do_op(vdc, VD_OP_BREAD, (caddr_t)buffer, vdc->vdisk_bsize,
6734 VD_SLICE_NONE, blkno, NULL, VIO_read_dir, flags);
6735
6736 done:
6737 kmem_free(buffer, vdc->vdisk_bsize);
6738 return (rv);
6739 }
6740
6741 /*
6742 * Add a pending I/O to the eio queue. An I/O is added to this queue
6743 * when it has failed and failfast is enabled or the vdisk has multiple
6744 * servers. It will then be handled by the eio thread (vdc_eio_thread).
6745 * The eio queue is ordered starting with the most recent I/O added.
6746 */
6747 static vdc_io_t *
6748 vdc_eio_queue(vdc_t *vdc, int index)
6749 {
6750 vdc_io_t *vio;
6751
6752 ASSERT(MUTEX_HELD(&vdc->lock));
6753
6754 vio = kmem_alloc(sizeof (vdc_io_t), KM_SLEEP);
6755 vio->vio_next = vdc->eio_queue;
6756 vio->vio_index = index;
6757 vio->vio_qtime = ddi_get_lbolt();
6758
6759 vdc->eio_queue = vio;
6760
6761 /* notify the eio thread that a new I/O is queued */
6762 cv_signal(&vdc->eio_cv);
6763
6764 return (vio);
6765 }
6766
6767 /*
6768 * Remove I/Os added before the indicated deadline from the eio queue. A
6769 * deadline of 0 means that all I/Os have to be unqueued. The complete_io
6770 * boolean specifies if unqueued I/Os should be marked as completed or not.
6771 */
6772 static void
6773 vdc_eio_unqueue(vdc_t *vdc, clock_t deadline, boolean_t complete_io)
6774 {
6775 struct buf *buf;
6776 vdc_io_t *vio, *vio_tmp;
6777 int index, op;
6778
6779 ASSERT(MUTEX_HELD(&vdc->lock));
6780
6781 vio_tmp = NULL;
6782 vio = vdc->eio_queue;
6783
6784 if (deadline != 0) {
6785 /*
6786 * Skip any io queued after the deadline. The eio queue is
6787 * ordered starting with the last I/O added to the queue.
6788 */
6789 while (vio != NULL && vio->vio_qtime > deadline) {
6790 vio_tmp = vio;
6791 vio = vio->vio_next;
6792 }
6793 }
6794
6795 if (vio == NULL)
6796 /* nothing to unqueue */
6797 return;
6798
6799 /* update the queue */
6800 if (vio_tmp == NULL)
6801 vdc->eio_queue = NULL;
6802 else
6803 vio_tmp->vio_next = NULL;
6804
6805 /*
6806 * Free and complete unqueued I/Os if this was requested. All I/Os
6807 * have a block I/O data transfer structure (buf) and they are
6808 * completed by calling biodone().
6809 */
6810 while (vio != NULL) {
6811 vio_tmp = vio->vio_next;
6812
6813 if (complete_io) {
6814 index = vio->vio_index;
6815 op = vdc->local_dring[index].operation;
6816 buf = vdc->local_dring[index].buf;
6817 (void) vdc_depopulate_descriptor(vdc, index);
6818 ASSERT(buf->b_flags & B_ERROR);
6819 if (op == VD_OP_BREAD || op == VD_OP_BWRITE) {
6820 VD_UPDATE_ERR_STATS(vdc, vd_softerrs);
6821 VD_KSTAT_RUNQ_EXIT(vdc);
6822 DTRACE_IO1(done, buf_t *, buf);
6823 }
6824 biodone(buf);
6825 }
6826
6827 kmem_free(vio, sizeof (vdc_io_t));
6828 vio = vio_tmp;
6829 }
6830 }
6831
6832 /*
6833 * Error I/O Thread. There is one eio thread for each virtual disk that
6834 * has multiple servers or for which failfast is enabled. Failfast can only
6835 * be enabled for vdisk supporting SCSI commands.
6836 *
6837 * While failfast is enabled, the eio thread sends a TEST UNIT READY
6838 * and a zero size WRITE(10) SCSI commands on a regular basis to check that
6839 * we still have access to the disk. If a command fails with a RESERVATION
6840 * CONFLICT error then the system will immediatly panic.
6841 *
6842 * The eio thread is also woken up when an I/O has failed. It then checks
6843 * the access to the disk to ensure that the I/O failure was not due to a
6844 * reservation conflict or to the backend been inaccessible.
6845 *
6846 */
6847 static void
6848 vdc_eio_thread(void *arg)
6849 {
6850 int status;
6851 vdc_t *vdc = (vdc_t *)arg;
6852 clock_t starttime, timeout = drv_usectohz(vdc->failfast_interval);
6853
6854 mutex_enter(&vdc->lock);
6855
6856 while (vdc->failfast_interval != 0 || vdc->num_servers > 1) {
6857 /*
6858 * Wait if there is nothing in the eio queue or if the state
6859 * is not VDC_STATE_RUNNING.
6860 */
6861 if (vdc->eio_queue == NULL || vdc->state != VDC_STATE_RUNNING) {
6862 if (vdc->failfast_interval != 0) {
6863 timeout = ddi_get_lbolt() +
6864 drv_usectohz(vdc->failfast_interval);
6865 (void) cv_timedwait(&vdc->eio_cv, &vdc->lock,
6866 timeout);
6867 } else {
6868 ASSERT(vdc->num_servers > 1);
6869 (void) cv_wait(&vdc->eio_cv, &vdc->lock);
6870 }
6871
6872 if (vdc->state != VDC_STATE_RUNNING)
6873 continue;
6874 }
6875
6876 mutex_exit(&vdc->lock);
6877
6878 starttime = ddi_get_lbolt();
6879
6880 /* check error */
6881 status = vdc_eio_check(vdc, VDC_OP_STATE_RUNNING);
6882
6883 mutex_enter(&vdc->lock);
6884 /*
6885 * We have dropped the lock to check the backend so we have
6886 * to check that the eio thread is still enabled.
6887 */
6888 if (vdc->failfast_interval == 0 && vdc->num_servers <= 1)
6889 break;
6890
6891 /*
6892 * If the eio queue is empty or we are not in running state
6893 * anymore then there is nothing to do.
6894 */
6895 if (vdc->state != VDC_STATE_RUNNING || vdc->eio_queue == NULL)
6896 continue;
6897
6898 if (status == 0) {
6899 /*
6900 * The backend access has been successfully checked,
6901 * we can complete any I/O queued before the last check.
6902 */
6903 vdc_eio_unqueue(vdc, starttime, B_TRUE);
6904
6905 } else if (vdc->num_servers > 1) {
6906 /*
6907 * The backend is inaccessible for a disk with multiple
6908 * servers. So we force a reset to switch to another
6909 * server. The reset will also clear the eio queue and
6910 * resubmit all pending I/Os.
6911 */
6912 mutex_enter(&vdc->read_lock);
6913 vdc->read_state = VDC_READ_RESET;
6914 cv_signal(&vdc->read_cv);
6915 mutex_exit(&vdc->read_lock);
6916 } else {
6917 /*
6918 * There is only one path and the backend is not
6919 * accessible, so I/Os are actually failing because
6920 * of that. So we can complete I/O queued before the
6921 * last check.
6922 */
6923 vdc_eio_unqueue(vdc, starttime, B_TRUE);
6924 }
6925 }
6926
6927 /*
6928 * The thread is being stopped so we can complete any queued I/O.
6929 */
6930 vdc_eio_unqueue(vdc, 0, B_TRUE);
6931 vdc->eio_thread = NULL;
6932 mutex_exit(&vdc->lock);
6933 thread_exit();
6934 }
6935
6936 /*
6937 * Implement the MHIOCENFAILFAST mhd(7i) ioctl.
6938 */
6939 static int
6940 vdc_failfast(vdc_t *vdc, caddr_t arg, int mode)
6941 {
6942 unsigned int mh_time;
6943
6944 if (ddi_copyin((void *)arg, &mh_time, sizeof (int), mode))
6945 return (EFAULT);
6946
6947 mutex_enter(&vdc->lock);
6948 if (mh_time != 0 && vdc->eio_thread == NULL) {
6949 vdc->eio_thread = thread_create(NULL, 0,
6950 vdc_eio_thread, vdc, 0, &p0, TS_RUN,
6951 v.v_maxsyspri - 2);
6952 }
6953
6954 vdc->failfast_interval = ((long)mh_time) * MILLISEC;
6955 cv_signal(&vdc->eio_cv);
6956 mutex_exit(&vdc->lock);
6957
6958 return (0);
6959 }
6960
6961 /*
6962 * Implement the MHIOCTKOWN and MHIOCRELEASE mhd(7i) ioctls. These ioctls are
6963 * converted to VD_OP_SET_ACCESS operations.
6964 */
6965 static int
6966 vdc_access_set(vdc_t *vdc, uint64_t flags)
6967 {
6968 int rv;
6969
6970 /* submit owership command request */
6971 rv = vdc_do_sync_op(vdc, VD_OP_SET_ACCESS, (caddr_t)&flags,
6972 sizeof (uint64_t), 0, 0, VIO_both_dir, B_TRUE);
6973
6974 return (rv);
6975 }
6976
6977 /*
6978 * Implement the MHIOCSTATUS mhd(7i) ioctl. This ioctl is converted to a
6979 * VD_OP_GET_ACCESS operation.
6980 */
6981 static int
6982 vdc_access_get(vdc_t *vdc, uint64_t *status)
6983 {
6984 int rv;
6985
6986 /* submit owership command request */
6987 rv = vdc_do_sync_op(vdc, VD_OP_GET_ACCESS, (caddr_t)status,
6988 sizeof (uint64_t), 0, 0, VIO_both_dir, B_TRUE);
6989
6990 return (rv);
6991 }
6992
6993 /*
6994 * Disk Ownership Thread.
6995 *
6996 * When we have taken the ownership of a disk, this thread waits to be
6997 * notified when the LDC channel is reset so that it can recover the
6998 * ownership.
6999 *
7000 * Note that the thread handling the LDC reset (vdc_process_msg_thread())
7001 * can not be used to do the ownership recovery because it has to be
7002 * running to handle the reply message to the ownership operation.
7003 */
7004 static void
7005 vdc_ownership_thread(void *arg)
7006 {
7007 vdc_t *vdc = (vdc_t *)arg;
7008 clock_t timeout;
7009 uint64_t status;
7010
7011 mutex_enter(&vdc->ownership_lock);
7012 mutex_enter(&vdc->lock);
7013
7014 while (vdc->ownership & VDC_OWNERSHIP_WANTED) {
7015
7016 if ((vdc->ownership & VDC_OWNERSHIP_RESET) ||
7017 !(vdc->ownership & VDC_OWNERSHIP_GRANTED)) {
7018 /*
7019 * There was a reset so the ownership has been lost,
7020 * try to recover. We do this without using the preempt
7021 * option so that we don't steal the ownership from
7022 * someone who has preempted us.
7023 */
7024 DMSG(vdc, 0, "[%d] Ownership lost, recovering",
7025 vdc->instance);
7026
7027 vdc->ownership &= ~(VDC_OWNERSHIP_RESET |
7028 VDC_OWNERSHIP_GRANTED);
7029
7030 mutex_exit(&vdc->lock);
7031
7032 status = vdc_access_set(vdc, VD_ACCESS_SET_EXCLUSIVE |
7033 VD_ACCESS_SET_PRESERVE);
7034
7035 mutex_enter(&vdc->lock);
7036
7037 if (status == 0) {
7038 DMSG(vdc, 0, "[%d] Ownership recovered",
7039 vdc->instance);
7040 vdc->ownership |= VDC_OWNERSHIP_GRANTED;
7041 } else {
7042 DMSG(vdc, 0, "[%d] Fail to recover ownership",
7043 vdc->instance);
7044 }
7045
7046 }
7047
7048 /*
7049 * If we have the ownership then we just wait for an event
7050 * to happen (LDC reset), otherwise we will retry to recover
7051 * after a delay.
7052 */
7053 if (vdc->ownership & VDC_OWNERSHIP_GRANTED)
7054 timeout = 0;
7055 else
7056 timeout = drv_usectohz(vdc_ownership_delay);
7057
7058 /* Release the ownership_lock and wait on the vdc lock */
7059 mutex_exit(&vdc->ownership_lock);
7060
7061 if (timeout == 0)
7062 (void) cv_wait(&vdc->ownership_cv, &vdc->lock);
7063 else
7064 (void) cv_reltimedwait(&vdc->ownership_cv, &vdc->lock,
7065 timeout, TR_CLOCK_TICK);
7066
7067 mutex_exit(&vdc->lock);
7068
7069 mutex_enter(&vdc->ownership_lock);
7070 mutex_enter(&vdc->lock);
7071 }
7072
7073 vdc->ownership_thread = NULL;
7074 mutex_exit(&vdc->lock);
7075 mutex_exit(&vdc->ownership_lock);
7076
7077 thread_exit();
7078 }
7079
7080 static void
7081 vdc_ownership_update(vdc_t *vdc, int ownership_flags)
7082 {
7083 ASSERT(MUTEX_HELD(&vdc->ownership_lock));
7084
7085 mutex_enter(&vdc->lock);
7086 vdc->ownership = ownership_flags;
7087 if ((vdc->ownership & VDC_OWNERSHIP_WANTED) &&
7088 vdc->ownership_thread == NULL) {
7089 /* start ownership thread */
7090 vdc->ownership_thread = thread_create(NULL, 0,
7091 vdc_ownership_thread, vdc, 0, &p0, TS_RUN,
7092 v.v_maxsyspri - 2);
7093 } else {
7094 /* notify the ownership thread */
7095 cv_signal(&vdc->ownership_cv);
7096 }
7097 mutex_exit(&vdc->lock);
7098 }
7099
7100 /*
7101 * Get the size and the block size of a virtual disk from the vdisk server.
7102 */
7103 static int
7104 vdc_get_capacity(vdc_t *vdc, size_t *dsk_size, size_t *blk_size)
7105 {
7106 int rv = 0;
7107 size_t alloc_len;
7108 vd_capacity_t *vd_cap;
7109
7110 ASSERT(MUTEX_NOT_HELD(&vdc->lock));
7111
7112 alloc_len = P2ROUNDUP(sizeof (vd_capacity_t), sizeof (uint64_t));
7113
7114 vd_cap = kmem_zalloc(alloc_len, KM_SLEEP);
7115
7116 rv = vdc_do_sync_op(vdc, VD_OP_GET_CAPACITY, (caddr_t)vd_cap, alloc_len,
7117 0, 0, VIO_both_dir, B_TRUE);
7118
7119 *dsk_size = vd_cap->vdisk_size;
7120 *blk_size = vd_cap->vdisk_block_size;
7121
7122 kmem_free(vd_cap, alloc_len);
7123 return (rv);
7124 }
7125
7126 /*
7127 * Check the disk capacity. Disk size information is updated if size has
7128 * changed.
7129 *
7130 * Return 0 if the disk capacity is available, or non-zero if it is not.
7131 */
7132 static int
7133 vdc_check_capacity(vdc_t *vdc)
7134 {
7135 size_t dsk_size, blk_size;
7136 int rv;
7137
7138 /*
7139 * If the vdisk does not support the VD_OP_GET_CAPACITY operation
7140 * then the disk capacity has been retrieved during the handshake
7141 * and there's nothing more to do here.
7142 */
7143 if (!VD_OP_SUPPORTED(vdc->operations, VD_OP_GET_CAPACITY))
7144 return (0);
7145
7146 if ((rv = vdc_get_capacity(vdc, &dsk_size, &blk_size)) != 0)
7147 return (rv);
7148
7149 if (dsk_size == VD_SIZE_UNKNOWN || dsk_size == 0 || blk_size == 0)
7150 return (EINVAL);
7151
7152 mutex_enter(&vdc->lock);
7153 /*
7154 * First try to update the VIO block size (which is the same as the
7155 * vdisk block size). If this returns an error then that means that
7156 * we can not use that block size so basically the vdisk is unusable
7157 * and we return an error.
7158 */
7159 rv = vdc_update_vio_bsize(vdc, blk_size);
7160 if (rv == 0)
7161 vdc_update_size(vdc, dsk_size, blk_size, vdc->max_xfer_sz);
7162
7163 mutex_exit(&vdc->lock);
7164
7165 return (rv);
7166 }
7167
7168 /*
7169 * This structure is used in the DKIO(7I) array below.
7170 */
7171 typedef struct vdc_dk_ioctl {
7172 uint8_t op; /* VD_OP_XXX value */
7173 int cmd; /* Solaris ioctl operation number */
7174 size_t nbytes; /* size of structure to be copied */
7175
7176 /* function to convert between vDisk and Solaris structure formats */
7177 int (*convert)(vdc_t *vdc, void *vd_buf, void *ioctl_arg,
7178 int mode, int dir);
7179 } vdc_dk_ioctl_t;
7180
7181 /*
7182 * Subset of DKIO(7I) operations currently supported
7183 */
7184 static vdc_dk_ioctl_t dk_ioctl[] = {
7185 {VD_OP_FLUSH, DKIOCFLUSHWRITECACHE, 0,
7186 vdc_null_copy_func},
7187 {VD_OP_GET_WCE, DKIOCGETWCE, sizeof (int),
7188 vdc_get_wce_convert},
7189 {VD_OP_SET_WCE, DKIOCSETWCE, sizeof (int),
7190 vdc_set_wce_convert},
7191 {VD_OP_GET_VTOC, DKIOCGVTOC, sizeof (vd_vtoc_t),
7192 vdc_get_vtoc_convert},
7193 {VD_OP_SET_VTOC, DKIOCSVTOC, sizeof (vd_vtoc_t),
7194 vdc_set_vtoc_convert},
7195 {VD_OP_GET_VTOC, DKIOCGEXTVTOC, sizeof (vd_vtoc_t),
7196 vdc_get_extvtoc_convert},
7197 {VD_OP_SET_VTOC, DKIOCSEXTVTOC, sizeof (vd_vtoc_t),
7198 vdc_set_extvtoc_convert},
7199 {VD_OP_GET_DISKGEOM, DKIOCGGEOM, sizeof (vd_geom_t),
7200 vdc_get_geom_convert},
7201 {VD_OP_GET_DISKGEOM, DKIOCG_PHYGEOM, sizeof (vd_geom_t),
7202 vdc_get_geom_convert},
7203 {VD_OP_GET_DISKGEOM, DKIOCG_VIRTGEOM, sizeof (vd_geom_t),
7204 vdc_get_geom_convert},
7205 {VD_OP_SET_DISKGEOM, DKIOCSGEOM, sizeof (vd_geom_t),
7206 vdc_set_geom_convert},
7207 {VD_OP_GET_EFI, DKIOCGETEFI, 0,
7208 vdc_get_efi_convert},
7209 {VD_OP_SET_EFI, DKIOCSETEFI, 0,
7210 vdc_set_efi_convert},
7211
7212 /* DIOCTL_RWCMD is converted to a read or a write */
7213 {0, DIOCTL_RWCMD, sizeof (struct dadkio_rwcmd), NULL},
7214
7215 /* mhd(7I) non-shared multihost disks ioctls */
7216 {0, MHIOCTKOWN, 0, vdc_null_copy_func},
7217 {0, MHIOCRELEASE, 0, vdc_null_copy_func},
7218 {0, MHIOCSTATUS, 0, vdc_null_copy_func},
7219 {0, MHIOCQRESERVE, 0, vdc_null_copy_func},
7220
7221 /* mhd(7I) shared multihost disks ioctls */
7222 {0, MHIOCGRP_INKEYS, 0, vdc_null_copy_func},
7223 {0, MHIOCGRP_INRESV, 0, vdc_null_copy_func},
7224 {0, MHIOCGRP_REGISTER, 0, vdc_null_copy_func},
7225 {0, MHIOCGRP_RESERVE, 0, vdc_null_copy_func},
7226 {0, MHIOCGRP_PREEMPTANDABORT, 0, vdc_null_copy_func},
7227 {0, MHIOCGRP_REGISTERANDIGNOREKEY, 0, vdc_null_copy_func},
7228
7229 /* mhd(7I) failfast ioctl */
7230 {0, MHIOCENFAILFAST, 0, vdc_null_copy_func},
7231
7232 /*
7233 * These particular ioctls are not sent to the server - vdc fakes up
7234 * the necessary info.
7235 */
7236 {0, DKIOCINFO, sizeof (struct dk_cinfo), vdc_null_copy_func},
7237 {0, DKIOCGMEDIAINFO, sizeof (struct dk_minfo), vdc_null_copy_func},
7238 {0, USCSICMD, sizeof (struct uscsi_cmd), vdc_null_copy_func},
7239 {0, DKIOCPARTITION, 0, vdc_null_copy_func },
7240 {0, DKIOCGAPART, 0, vdc_null_copy_func },
7241 {0, DKIOCREMOVABLE, 0, vdc_null_copy_func},
7242 {0, CDROMREADOFFSET, 0, vdc_null_copy_func}
7243 };
7244
7245 /*
7246 * This function handles ioctl requests from the vd_efi_alloc_and_read()
7247 * function and forward them to the vdisk.
7248 */
7249 static int
7250 vd_process_efi_ioctl(void *vdisk, int cmd, uintptr_t arg)
7251 {
7252 vdc_t *vdc = (vdc_t *)vdisk;
7253 dev_t dev;
7254 int rval;
7255
7256 dev = makedevice(ddi_driver_major(vdc->dip),
7257 VD_MAKE_DEV(vdc->instance, 0));
7258
7259 return (vd_process_ioctl(dev, cmd, (caddr_t)arg, FKIOCTL, &rval));
7260 }
7261
7262 /*
7263 * Function:
7264 * vd_process_ioctl()
7265 *
7266 * Description:
7267 * This routine processes disk specific ioctl calls
7268 *
7269 * Arguments:
7270 * dev - the device number
7271 * cmd - the operation [dkio(7I)] to be processed
7272 * arg - pointer to user provided structure
7273 * (contains data to be set or reference parameter for get)
7274 * mode - bit flag, indicating open settings, 32/64 bit type, etc
7275 * rvalp - pointer to return value for calling process.
7276 *
7277 * Return Code:
7278 * 0
7279 * EFAULT
7280 * ENXIO
7281 * EIO
7282 * ENOTSUP
7283 */
7284 static int
7285 vd_process_ioctl(dev_t dev, int cmd, caddr_t arg, int mode, int *rvalp)
7286 {
7287 int instance = VDCUNIT(dev);
7288 vdc_t *vdc = NULL;
7289 int rv = -1;
7290 int idx = 0; /* index into dk_ioctl[] */
7291 size_t len = 0; /* #bytes to send to vds */
7292 size_t alloc_len = 0; /* #bytes to allocate mem for */
7293 caddr_t mem_p = NULL;
7294 size_t nioctls = (sizeof (dk_ioctl)) / (sizeof (dk_ioctl[0]));
7295 vdc_dk_ioctl_t *iop;
7296
7297 vdc = ddi_get_soft_state(vdc_state, instance);
7298 if (vdc == NULL) {
7299 cmn_err(CE_NOTE, "![%d] Could not get soft state structure",
7300 instance);
7301 return (ENXIO);
7302 }
7303
7304 DMSG(vdc, 0, "[%d] Processing ioctl(%x) for dev %lx : model %x\n",
7305 instance, cmd, dev, ddi_model_convert_from(mode & FMODELS));
7306
7307 if (rvalp != NULL) {
7308 /* the return value of the ioctl is 0 by default */
7309 *rvalp = 0;
7310 }
7311
7312 /*
7313 * Validate the ioctl operation to be performed.
7314 *
7315 * If we have looped through the array without finding a match then we
7316 * don't support this ioctl.
7317 */
7318 for (idx = 0; idx < nioctls; idx++) {
7319 if (cmd == dk_ioctl[idx].cmd)
7320 break;
7321 }
7322
7323 if (idx >= nioctls) {
7324 DMSG(vdc, 0, "[%d] Unsupported ioctl (0x%x)\n",
7325 vdc->instance, cmd);
7326 return (ENOTSUP);
7327 }
7328
7329 iop = &(dk_ioctl[idx]);
7330
7331 if (cmd == DKIOCGETEFI || cmd == DKIOCSETEFI) {
7332 /* size is not fixed for EFI ioctls, it depends on ioctl arg */
7333 dk_efi_t dk_efi;
7334
7335 rv = ddi_copyin(arg, &dk_efi, sizeof (dk_efi_t), mode);
7336 if (rv != 0)
7337 return (EFAULT);
7338
7339 len = sizeof (vd_efi_t) - 1 + dk_efi.dki_length;
7340 } else {
7341 len = iop->nbytes;
7342 }
7343
7344 /* check if the ioctl is applicable */
7345 switch (cmd) {
7346 case CDROMREADOFFSET:
7347 case DKIOCREMOVABLE:
7348 return (ENOTTY);
7349
7350 case USCSICMD:
7351 case MHIOCTKOWN:
7352 case MHIOCSTATUS:
7353 case MHIOCQRESERVE:
7354 case MHIOCRELEASE:
7355 case MHIOCGRP_INKEYS:
7356 case MHIOCGRP_INRESV:
7357 case MHIOCGRP_REGISTER:
7358 case MHIOCGRP_RESERVE:
7359 case MHIOCGRP_PREEMPTANDABORT:
7360 case MHIOCGRP_REGISTERANDIGNOREKEY:
7361 case MHIOCENFAILFAST:
7362 if (vdc->cinfo == NULL)
7363 return (ENXIO);
7364 if (vdc->cinfo->dki_ctype != DKC_SCSI_CCS)
7365 return (ENOTTY);
7366 break;
7367
7368 case DIOCTL_RWCMD:
7369 if (vdc->cinfo == NULL)
7370 return (ENXIO);
7371 if (vdc->cinfo->dki_ctype != DKC_DIRECT)
7372 return (ENOTTY);
7373 break;
7374
7375 case DKIOCINFO:
7376 if (vdc->cinfo == NULL)
7377 return (ENXIO);
7378 break;
7379
7380 case DKIOCGMEDIAINFO:
7381 if (vdc->minfo == NULL)
7382 return (ENXIO);
7383 if (vdc_check_capacity(vdc) != 0)
7384 /* disk capacity is not available */
7385 return (EIO);
7386 break;
7387 }
7388
7389 /*
7390 * Deal with ioctls which require a processing different than
7391 * converting ioctl arguments and sending a corresponding
7392 * VD operation.
7393 */
7394 switch (cmd) {
7395
7396 case USCSICMD:
7397 {
7398 return (vdc_uscsi_cmd(vdc, arg, mode));
7399 }
7400
7401 case MHIOCTKOWN:
7402 {
7403 mutex_enter(&vdc->ownership_lock);
7404 /*
7405 * We have to set VDC_OWNERSHIP_WANTED now so that the ownership
7406 * can be flagged with VDC_OWNERSHIP_RESET if the LDC is reset
7407 * while we are processing the ioctl.
7408 */
7409 vdc_ownership_update(vdc, VDC_OWNERSHIP_WANTED);
7410
7411 rv = vdc_access_set(vdc, VD_ACCESS_SET_EXCLUSIVE |
7412 VD_ACCESS_SET_PREEMPT | VD_ACCESS_SET_PRESERVE);
7413 if (rv == 0) {
7414 vdc_ownership_update(vdc, VDC_OWNERSHIP_WANTED |
7415 VDC_OWNERSHIP_GRANTED);
7416 } else {
7417 vdc_ownership_update(vdc, VDC_OWNERSHIP_NONE);
7418 }
7419 mutex_exit(&vdc->ownership_lock);
7420 return (rv);
7421 }
7422
7423 case MHIOCRELEASE:
7424 {
7425 mutex_enter(&vdc->ownership_lock);
7426 rv = vdc_access_set(vdc, VD_ACCESS_SET_CLEAR);
7427 if (rv == 0) {
7428 vdc_ownership_update(vdc, VDC_OWNERSHIP_NONE);
7429 }
7430 mutex_exit(&vdc->ownership_lock);
7431 return (rv);
7432 }
7433
7434 case MHIOCSTATUS:
7435 {
7436 uint64_t status;
7437
7438 rv = vdc_access_get(vdc, &status);
7439 if (rv == 0 && rvalp != NULL)
7440 *rvalp = (status & VD_ACCESS_ALLOWED)? 0 : 1;
7441 return (rv);
7442 }
7443
7444 case MHIOCQRESERVE:
7445 {
7446 rv = vdc_access_set(vdc, VD_ACCESS_SET_EXCLUSIVE);
7447 return (rv);
7448 }
7449
7450 case MHIOCGRP_INKEYS:
7451 {
7452 return (vdc_mhd_inkeys(vdc, arg, mode));
7453 }
7454
7455 case MHIOCGRP_INRESV:
7456 {
7457 return (vdc_mhd_inresv(vdc, arg, mode));
7458 }
7459
7460 case MHIOCGRP_REGISTER:
7461 {
7462 return (vdc_mhd_register(vdc, arg, mode));
7463 }
7464
7465 case MHIOCGRP_RESERVE:
7466 {
7467 return (vdc_mhd_reserve(vdc, arg, mode));
7468 }
7469
7470 case MHIOCGRP_PREEMPTANDABORT:
7471 {
7472 return (vdc_mhd_preemptabort(vdc, arg, mode));
7473 }
7474
7475 case MHIOCGRP_REGISTERANDIGNOREKEY:
7476 {
7477 return (vdc_mhd_registerignore(vdc, arg, mode));
7478 }
7479
7480 case MHIOCENFAILFAST:
7481 {
7482 rv = vdc_failfast(vdc, arg, mode);
7483 return (rv);
7484 }
7485
7486 case DIOCTL_RWCMD:
7487 {
7488 return (vdc_dioctl_rwcmd(vdc, arg, mode));
7489 }
7490
7491 case DKIOCGAPART:
7492 {
7493 return (vdc_dkio_gapart(vdc, arg, mode));
7494 }
7495
7496 case DKIOCPARTITION:
7497 {
7498 return (vdc_dkio_partition(vdc, arg, mode));
7499 }
7500
7501 case DKIOCINFO:
7502 {
7503 struct dk_cinfo cinfo;
7504
7505 bcopy(vdc->cinfo, &cinfo, sizeof (struct dk_cinfo));
7506 cinfo.dki_partition = VDCPART(dev);
7507
7508 rv = ddi_copyout(&cinfo, (void *)arg,
7509 sizeof (struct dk_cinfo), mode);
7510 if (rv != 0)
7511 return (EFAULT);
7512
7513 return (0);
7514 }
7515
7516 case DKIOCGMEDIAINFO:
7517 {
7518 ASSERT(vdc->vdisk_size != 0);
7519 ASSERT(vdc->minfo->dki_capacity != 0);
7520 rv = ddi_copyout(vdc->minfo, (void *)arg,
7521 sizeof (struct dk_minfo), mode);
7522 if (rv != 0)
7523 return (EFAULT);
7524
7525 return (0);
7526 }
7527
7528 case DKIOCFLUSHWRITECACHE:
7529 {
7530 struct dk_callback *dkc =
7531 (struct dk_callback *)(uintptr_t)arg;
7532 vdc_dk_arg_t *dkarg = NULL;
7533
7534 DMSG(vdc, 1, "[%d] Flush W$: mode %x\n",
7535 instance, mode);
7536
7537 /*
7538 * If arg is NULL, then there is no callback function
7539 * registered and the call operates synchronously; we
7540 * break and continue with the rest of the function and
7541 * wait for vds to return (i.e. after the request to
7542 * vds returns successfully, all writes completed prior
7543 * to the ioctl will have been flushed from the disk
7544 * write cache to persistent media.
7545 *
7546 * If a callback function is registered, we dispatch
7547 * the request on a task queue and return immediately.
7548 * The callback will deal with informing the calling
7549 * thread that the flush request is completed.
7550 */
7551 if (dkc == NULL)
7552 break;
7553
7554 /*
7555 * the asynchronous callback is only supported if
7556 * invoked from within the kernel
7557 */
7558 if ((mode & FKIOCTL) == 0)
7559 return (ENOTSUP);
7560
7561 dkarg = kmem_zalloc(sizeof (vdc_dk_arg_t), KM_SLEEP);
7562
7563 dkarg->mode = mode;
7564 dkarg->dev = dev;
7565 bcopy(dkc, &dkarg->dkc, sizeof (*dkc));
7566
7567 mutex_enter(&vdc->lock);
7568 vdc->dkio_flush_pending++;
7569 dkarg->vdc = vdc;
7570 mutex_exit(&vdc->lock);
7571
7572 /* put the request on a task queue */
7573 rv = taskq_dispatch(system_taskq, vdc_dkio_flush_cb,
7574 (void *)dkarg, DDI_SLEEP);
7575 if (rv == NULL) {
7576 /* clean up if dispatch fails */
7577 mutex_enter(&vdc->lock);
7578 vdc->dkio_flush_pending--;
7579 mutex_exit(&vdc->lock);
7580 kmem_free(dkarg, sizeof (vdc_dk_arg_t));
7581 }
7582
7583 return (rv == NULL ? ENOMEM : 0);
7584 }
7585 }
7586
7587 /* catch programming error in vdc - should be a VD_OP_XXX ioctl */
7588 ASSERT(iop->op != 0);
7589
7590 /* check if the vDisk server handles the operation for this vDisk */
7591 if (VD_OP_SUPPORTED(vdc->operations, iop->op) == B_FALSE) {
7592 DMSG(vdc, 0, "[%d] Unsupported VD_OP operation (0x%x)\n",
7593 vdc->instance, iop->op);
7594 return (ENOTSUP);
7595 }
7596
7597 /* LDC requires that the memory being mapped is 8-byte aligned */
7598 alloc_len = P2ROUNDUP(len, sizeof (uint64_t));
7599 DMSG(vdc, 1, "[%d] struct size %ld alloc %ld\n",
7600 instance, len, alloc_len);
7601
7602 if (alloc_len > 0)
7603 mem_p = kmem_zalloc(alloc_len, KM_SLEEP);
7604
7605 /*
7606 * Call the conversion function for this ioctl which, if necessary,
7607 * converts from the Solaris format to the format ARC'ed
7608 * as part of the vDisk protocol (FWARC 2006/195)
7609 */
7610 ASSERT(iop->convert != NULL);
7611 rv = (iop->convert)(vdc, arg, mem_p, mode, VD_COPYIN);
7612 if (rv != 0) {
7613 DMSG(vdc, 0, "[%d] convert func returned %d for ioctl 0x%x\n",
7614 instance, rv, cmd);
7615 if (mem_p != NULL)
7616 kmem_free(mem_p, alloc_len);
7617 return (rv);
7618 }
7619
7620 /*
7621 * send request to vds to service the ioctl.
7622 */
7623 rv = vdc_do_sync_op(vdc, iop->op, mem_p, alloc_len,
7624 VDCPART(dev), 0, VIO_both_dir, B_TRUE);
7625
7626 if (rv != 0) {
7627 /*
7628 * This is not necessarily an error. The ioctl could
7629 * be returning a value such as ENOTTY to indicate
7630 * that the ioctl is not applicable.
7631 */
7632 DMSG(vdc, 0, "[%d] vds returned %d for ioctl 0x%x\n",
7633 instance, rv, cmd);
7634 if (mem_p != NULL)
7635 kmem_free(mem_p, alloc_len);
7636
7637 return (rv);
7638 }
7639
7640 /*
7641 * Call the conversion function (if it exists) for this ioctl
7642 * which converts from the format ARC'ed as part of the vDisk
7643 * protocol (FWARC 2006/195) back to a format understood by
7644 * the rest of Solaris.
7645 */
7646 rv = (iop->convert)(vdc, mem_p, arg, mode, VD_COPYOUT);
7647 if (rv != 0) {
7648 DMSG(vdc, 0, "[%d] convert func returned %d for ioctl 0x%x\n",
7649 instance, rv, cmd);
7650 if (mem_p != NULL)
7651 kmem_free(mem_p, alloc_len);
7652 return (rv);
7653 }
7654
7655 if (mem_p != NULL)
7656 kmem_free(mem_p, alloc_len);
7657
7658 return (rv);
7659 }
7660
7661 /*
7662 * Function:
7663 *
7664 * Description:
7665 * This is an empty conversion function used by ioctl calls which
7666 * do not need to convert the data being passed in/out to userland
7667 */
7668 static int
7669 vdc_null_copy_func(vdc_t *vdc, void *from, void *to, int mode, int dir)
7670 {
7671 _NOTE(ARGUNUSED(vdc))
7672 _NOTE(ARGUNUSED(from))
7673 _NOTE(ARGUNUSED(to))
7674 _NOTE(ARGUNUSED(mode))
7675 _NOTE(ARGUNUSED(dir))
7676
7677 return (0);
7678 }
7679
7680 static int
7681 vdc_get_wce_convert(vdc_t *vdc, void *from, void *to,
7682 int mode, int dir)
7683 {
7684 _NOTE(ARGUNUSED(vdc))
7685
7686 if (dir == VD_COPYIN)
7687 return (0); /* nothing to do */
7688
7689 if (ddi_copyout(from, to, sizeof (int), mode) != 0)
7690 return (EFAULT);
7691
7692 return (0);
7693 }
7694
7695 static int
7696 vdc_set_wce_convert(vdc_t *vdc, void *from, void *to,
7697 int mode, int dir)
7698 {
7699 _NOTE(ARGUNUSED(vdc))
7700
7701 if (dir == VD_COPYOUT)
7702 return (0); /* nothing to do */
7703
7704 if (ddi_copyin(from, to, sizeof (int), mode) != 0)
7705 return (EFAULT);
7706
7707 return (0);
7708 }
7709
7710 /*
7711 * Function:
7712 * vdc_get_vtoc_convert()
7713 *
7714 * Description:
7715 * This routine performs the necessary convertions from the DKIOCGVTOC
7716 * Solaris structure to the format defined in FWARC 2006/195.
7717 *
7718 * In the struct vtoc definition, the timestamp field is marked as not
7719 * supported so it is not part of vDisk protocol (FWARC 2006/195).
7720 * However SVM uses that field to check it can write into the VTOC,
7721 * so we fake up the info of that field.
7722 *
7723 * Arguments:
7724 * vdc - the vDisk client
7725 * from - the buffer containing the data to be copied from
7726 * to - the buffer to be copied to
7727 * mode - flags passed to ioctl() call
7728 * dir - the "direction" of the copy - VD_COPYIN or VD_COPYOUT
7729 *
7730 * Return Code:
7731 * 0 - Success
7732 * ENXIO - incorrect buffer passed in.
7733 * EFAULT - ddi_copyout routine encountered an error.
7734 */
7735 static int
7736 vdc_get_vtoc_convert(vdc_t *vdc, void *from, void *to, int mode, int dir)
7737 {
7738 int i;
7739 struct vtoc vtoc;
7740 struct vtoc32 vtoc32;
7741 struct extvtoc evtoc;
7742 int rv;
7743
7744 if (dir != VD_COPYOUT)
7745 return (0); /* nothing to do */
7746
7747 if ((from == NULL) || (to == NULL))
7748 return (ENXIO);
7749
7750 if (vdc->vdisk_size > VD_OLDVTOC_LIMIT)
7751 return (EOVERFLOW);
7752
7753 VD_VTOC2VTOC((vd_vtoc_t *)from, &evtoc);
7754
7755 /* fake the VTOC timestamp field */
7756 for (i = 0; i < V_NUMPAR; i++) {
7757 evtoc.timestamp[i] = vdc->vtoc->timestamp[i];
7758 }
7759
7760 if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
7761 /* LINTED E_ASSIGN_NARROW_CONV */
7762 extvtoctovtoc32(evtoc, vtoc32);
7763 rv = ddi_copyout(&vtoc32, to, sizeof (vtoc32), mode);
7764 if (rv != 0)
7765 rv = EFAULT;
7766 } else {
7767 extvtoctovtoc(evtoc, vtoc);
7768 rv = ddi_copyout(&vtoc, to, sizeof (vtoc), mode);
7769 if (rv != 0)
7770 rv = EFAULT;
7771 }
7772
7773 return (rv);
7774 }
7775
7776 /*
7777 * Function:
7778 * vdc_set_vtoc_convert()
7779 *
7780 * Description:
7781 * This routine performs the necessary convertions from the DKIOCSVTOC
7782 * Solaris structure to the format defined in FWARC 2006/195.
7783 *
7784 * Arguments:
7785 * vdc - the vDisk client
7786 * from - Buffer with data
7787 * to - Buffer where data is to be copied to
7788 * mode - flags passed to ioctl
7789 * dir - direction of copy (in or out)
7790 *
7791 * Return Code:
7792 * 0 - Success
7793 * ENXIO - Invalid buffer passed in
7794 * EFAULT - ddi_copyin of data failed
7795 */
7796 static int
7797 vdc_set_vtoc_convert(vdc_t *vdc, void *from, void *to, int mode, int dir)
7798 {
7799 void *uvtoc;
7800 struct vtoc vtoc;
7801 struct vtoc32 vtoc32;
7802 struct extvtoc evtoc;
7803 int i, rv;
7804
7805 if ((from == NULL) || (to == NULL))
7806 return (ENXIO);
7807
7808 if (vdc->vdisk_size > VD_OLDVTOC_LIMIT)
7809 return (EOVERFLOW);
7810
7811 uvtoc = (dir == VD_COPYIN)? from : to;
7812
7813 if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
7814 rv = ddi_copyin(uvtoc, &vtoc32, sizeof (vtoc32), mode);
7815 if (rv != 0)
7816 return (EFAULT);
7817 vtoc32toextvtoc(vtoc32, evtoc);
7818 } else {
7819 rv = ddi_copyin(uvtoc, &vtoc, sizeof (vtoc), mode);
7820 if (rv != 0)
7821 return (EFAULT);
7822 vtoctoextvtoc(vtoc, evtoc);
7823 }
7824
7825 if (dir == VD_COPYOUT) {
7826 /*
7827 * The disk label may have changed. Revalidate the disk
7828 * geometry. This will also update the device nodes.
7829 */
7830 vdc_validate(vdc);
7831
7832 /*
7833 * We also need to keep track of the timestamp fields.
7834 */
7835 for (i = 0; i < V_NUMPAR; i++) {
7836 vdc->vtoc->timestamp[i] = evtoc.timestamp[i];
7837 }
7838
7839 } else {
7840 VTOC2VD_VTOC(&evtoc, (vd_vtoc_t *)to);
7841 }
7842
7843 return (0);
7844 }
7845
7846 static int
7847 vdc_get_extvtoc_convert(vdc_t *vdc, void *from, void *to, int mode, int dir)
7848 {
7849 int i, rv;
7850 struct extvtoc evtoc;
7851
7852 if (dir != VD_COPYOUT)
7853 return (0); /* nothing to do */
7854
7855 if ((from == NULL) || (to == NULL))
7856 return (ENXIO);
7857
7858 VD_VTOC2VTOC((vd_vtoc_t *)from, &evtoc);
7859
7860 /* fake the VTOC timestamp field */
7861 for (i = 0; i < V_NUMPAR; i++) {
7862 evtoc.timestamp[i] = vdc->vtoc->timestamp[i];
7863 }
7864
7865 rv = ddi_copyout(&evtoc, to, sizeof (struct extvtoc), mode);
7866 if (rv != 0)
7867 rv = EFAULT;
7868
7869 return (rv);
7870 }
7871
7872 static int
7873 vdc_set_extvtoc_convert(vdc_t *vdc, void *from, void *to, int mode, int dir)
7874 {
7875 void *uvtoc;
7876 struct extvtoc evtoc;
7877 int i, rv;
7878
7879 if ((from == NULL) || (to == NULL))
7880 return (ENXIO);
7881
7882 uvtoc = (dir == VD_COPYIN)? from : to;
7883
7884 rv = ddi_copyin(uvtoc, &evtoc, sizeof (struct extvtoc), mode);
7885 if (rv != 0)
7886 return (EFAULT);
7887
7888 if (dir == VD_COPYOUT) {
7889 /*
7890 * The disk label may have changed. Revalidate the disk
7891 * geometry. This will also update the device nodes.
7892 */
7893 vdc_validate(vdc);
7894
7895 /*
7896 * We also need to keep track of the timestamp fields.
7897 */
7898 for (i = 0; i < V_NUMPAR; i++) {
7899 vdc->vtoc->timestamp[i] = evtoc.timestamp[i];
7900 }
7901
7902 } else {
7903 VTOC2VD_VTOC(&evtoc, (vd_vtoc_t *)to);
7904 }
7905
7906 return (0);
7907 }
7908
7909 /*
7910 * Function:
7911 * vdc_get_geom_convert()
7912 *
7913 * Description:
7914 * This routine performs the necessary convertions from the DKIOCGGEOM,
7915 * DKIOCG_PHYSGEOM and DKIOG_VIRTGEOM Solaris structures to the format
7916 * defined in FWARC 2006/195
7917 *
7918 * Arguments:
7919 * vdc - the vDisk client
7920 * from - Buffer with data
7921 * to - Buffer where data is to be copied to
7922 * mode - flags passed to ioctl
7923 * dir - direction of copy (in or out)
7924 *
7925 * Return Code:
7926 * 0 - Success
7927 * ENXIO - Invalid buffer passed in
7928 * EFAULT - ddi_copyout of data failed
7929 */
7930 static int
7931 vdc_get_geom_convert(vdc_t *vdc, void *from, void *to, int mode, int dir)
7932 {
7933 _NOTE(ARGUNUSED(vdc))
7934
7935 struct dk_geom geom;
7936 int copy_len = sizeof (struct dk_geom);
7937 int rv = 0;
7938
7939 if (dir != VD_COPYOUT)
7940 return (0); /* nothing to do */
7941
7942 if ((from == NULL) || (to == NULL))
7943 return (ENXIO);
7944
7945 VD_GEOM2DK_GEOM((vd_geom_t *)from, &geom);
7946 rv = ddi_copyout(&geom, to, copy_len, mode);
7947 if (rv != 0)
7948 rv = EFAULT;
7949
7950 return (rv);
7951 }
7952
7953 /*
7954 * Function:
7955 * vdc_set_geom_convert()
7956 *
7957 * Description:
7958 * This routine performs the necessary convertions from the DKIOCSGEOM
7959 * Solaris structure to the format defined in FWARC 2006/195.
7960 *
7961 * Arguments:
7962 * vdc - the vDisk client
7963 * from - Buffer with data
7964 * to - Buffer where data is to be copied to
7965 * mode - flags passed to ioctl
7966 * dir - direction of copy (in or out)
7967 *
7968 * Return Code:
7969 * 0 - Success
7970 * ENXIO - Invalid buffer passed in
7971 * EFAULT - ddi_copyin of data failed
7972 */
7973 static int
7974 vdc_set_geom_convert(vdc_t *vdc, void *from, void *to, int mode, int dir)
7975 {
7976 _NOTE(ARGUNUSED(vdc))
7977
7978 vd_geom_t vdgeom;
7979 void *tmp_mem = NULL;
7980 int copy_len = sizeof (struct dk_geom);
7981 int rv = 0;
7982
7983 if (dir != VD_COPYIN)
7984 return (0); /* nothing to do */
7985
7986 if ((from == NULL) || (to == NULL))
7987 return (ENXIO);
7988
7989 tmp_mem = kmem_alloc(copy_len, KM_SLEEP);
7990
7991 rv = ddi_copyin(from, tmp_mem, copy_len, mode);
7992 if (rv != 0) {
7993 kmem_free(tmp_mem, copy_len);
7994 return (EFAULT);
7995 }
7996 DK_GEOM2VD_GEOM((struct dk_geom *)tmp_mem, &vdgeom);
7997 bcopy(&vdgeom, to, sizeof (vdgeom));
7998 kmem_free(tmp_mem, copy_len);
7999
8000 return (0);
8001 }
8002
8003 static int
8004 vdc_get_efi_convert(vdc_t *vdc, void *from, void *to, int mode, int dir)
8005 {
8006 _NOTE(ARGUNUSED(vdc))
8007
8008 vd_efi_t *vd_efi;
8009 dk_efi_t dk_efi;
8010 int rv = 0;
8011 void *uaddr;
8012
8013 if ((from == NULL) || (to == NULL))
8014 return (ENXIO);
8015
8016 if (dir == VD_COPYIN) {
8017
8018 vd_efi = (vd_efi_t *)to;
8019
8020 rv = ddi_copyin(from, &dk_efi, sizeof (dk_efi_t), mode);
8021 if (rv != 0)
8022 return (EFAULT);
8023
8024 vd_efi->lba = dk_efi.dki_lba;
8025 vd_efi->length = dk_efi.dki_length;
8026 bzero(vd_efi->data, vd_efi->length);
8027
8028 } else {
8029
8030 rv = ddi_copyin(to, &dk_efi, sizeof (dk_efi_t), mode);
8031 if (rv != 0)
8032 return (EFAULT);
8033
8034 uaddr = dk_efi.dki_data;
8035
8036 dk_efi.dki_data = kmem_alloc(dk_efi.dki_length, KM_SLEEP);
8037
8038 VD_EFI2DK_EFI((vd_efi_t *)from, &dk_efi);
8039
8040 rv = ddi_copyout(dk_efi.dki_data, uaddr, dk_efi.dki_length,
8041 mode);
8042 if (rv != 0)
8043 return (EFAULT);
8044
8045 kmem_free(dk_efi.dki_data, dk_efi.dki_length);
8046 }
8047
8048 return (0);
8049 }
8050
8051 static int
8052 vdc_set_efi_convert(vdc_t *vdc, void *from, void *to, int mode, int dir)
8053 {
8054 _NOTE(ARGUNUSED(vdc))
8055
8056 dk_efi_t dk_efi;
8057 void *uaddr;
8058
8059 if (dir == VD_COPYOUT) {
8060 /*
8061 * The disk label may have changed. Revalidate the disk
8062 * geometry. This will also update the device nodes.
8063 */
8064 vdc_validate(vdc);
8065 return (0);
8066 }
8067
8068 if ((from == NULL) || (to == NULL))
8069 return (ENXIO);
8070
8071 if (ddi_copyin(from, &dk_efi, sizeof (dk_efi_t), mode) != 0)
8072 return (EFAULT);
8073
8074 uaddr = dk_efi.dki_data;
8075
8076 dk_efi.dki_data = kmem_alloc(dk_efi.dki_length, KM_SLEEP);
8077
8078 if (ddi_copyin(uaddr, dk_efi.dki_data, dk_efi.dki_length, mode) != 0)
8079 return (EFAULT);
8080
8081 DK_EFI2VD_EFI(&dk_efi, (vd_efi_t *)to);
8082
8083 kmem_free(dk_efi.dki_data, dk_efi.dki_length);
8084
8085 return (0);
8086 }
8087
8088
8089 /* -------------------------------------------------------------------------- */
8090
8091 /*
8092 * Function:
8093 * vdc_create_fake_geometry()
8094 *
8095 * Description:
8096 * This routine fakes up the disk info needed for some DKIO ioctls such
8097 * as DKIOCINFO and DKIOCGMEDIAINFO [just like lofi(7D) and ramdisk(7D) do]
8098 *
8099 * Note: This function must not be called until the vDisk attributes have
8100 * been exchanged as part of the handshake with the vDisk server.
8101 *
8102 * Arguments:
8103 * vdc - soft state pointer for this instance of the device driver.
8104 *
8105 * Return Code:
8106 * none.
8107 */
8108 static void
8109 vdc_create_fake_geometry(vdc_t *vdc)
8110 {
8111 ASSERT(vdc != NULL);
8112 ASSERT(vdc->max_xfer_sz != 0);
8113
8114 /*
8115 * DKIOCINFO support
8116 */
8117 if (vdc->cinfo == NULL)
8118 vdc->cinfo = kmem_zalloc(sizeof (struct dk_cinfo), KM_SLEEP);
8119
8120 (void) strcpy(vdc->cinfo->dki_cname, VDC_DRIVER_NAME);
8121 (void) strcpy(vdc->cinfo->dki_dname, VDC_DRIVER_NAME);
8122 /* max_xfer_sz is #blocks so we don't need to divide by vdisk_bsize */
8123 vdc->cinfo->dki_maxtransfer = vdc->max_xfer_sz;
8124
8125 /*
8126 * We set the controller type to DKC_SCSI_CCS only if the VD_OP_SCSICMD
8127 * operation is supported, otherwise the controller type is DKC_DIRECT.
8128 * Version 1.0 does not support the VD_OP_SCSICMD operation, so the
8129 * controller type is always DKC_DIRECT in that case.
8130 *
8131 * If the virtual disk is backed by a physical CD/DVD device or
8132 * an ISO image, modify the controller type to indicate this
8133 */
8134 switch (vdc->vdisk_media) {
8135 case VD_MEDIA_CD:
8136 case VD_MEDIA_DVD:
8137 vdc->cinfo->dki_ctype = DKC_CDROM;
8138 break;
8139 case VD_MEDIA_FIXED:
8140 if (VD_OP_SUPPORTED(vdc->operations, VD_OP_SCSICMD))
8141 vdc->cinfo->dki_ctype = DKC_SCSI_CCS;
8142 else
8143 vdc->cinfo->dki_ctype = DKC_DIRECT;
8144 break;
8145 default:
8146 /* in the case of v1.0 we default to a fixed disk */
8147 vdc->cinfo->dki_ctype = DKC_DIRECT;
8148 break;
8149 }
8150 vdc->cinfo->dki_flags = DKI_FMTVOL;
8151 vdc->cinfo->dki_cnum = 0;
8152 vdc->cinfo->dki_addr = 0;
8153 vdc->cinfo->dki_space = 0;
8154 vdc->cinfo->dki_prio = 0;
8155 vdc->cinfo->dki_vec = 0;
8156 vdc->cinfo->dki_unit = vdc->instance;
8157 vdc->cinfo->dki_slave = 0;
8158 /*
8159 * The partition number will be created on the fly depending on the
8160 * actual slice (i.e. minor node) that is used to request the data.
8161 */
8162 vdc->cinfo->dki_partition = 0;
8163
8164 /*
8165 * DKIOCGMEDIAINFO support
8166 */
8167 if (vdc->minfo == NULL)
8168 vdc->minfo = kmem_zalloc(sizeof (struct dk_minfo), KM_SLEEP);
8169
8170 if (vio_ver_is_supported(vdc->ver, 1, 1)) {
8171 vdc->minfo->dki_media_type =
8172 VD_MEDIATYPE2DK_MEDIATYPE(vdc->vdisk_media);
8173 } else {
8174 vdc->minfo->dki_media_type = DK_FIXED_DISK;
8175 }
8176
8177 vdc->minfo->dki_capacity = vdc->vdisk_size;
8178 vdc->minfo->dki_lbsize = vdc->vdisk_bsize;
8179 }
8180
8181 static ushort_t
8182 vdc_lbl2cksum(struct dk_label *label)
8183 {
8184 int count;
8185 ushort_t sum, *sp;
8186
8187 count = (sizeof (struct dk_label)) / (sizeof (short)) - 1;
8188 sp = (ushort_t *)label;
8189 sum = 0;
8190 while (count--) {
8191 sum ^= *sp++;
8192 }
8193
8194 return (sum);
8195 }
8196
8197 static void
8198 vdc_update_size(vdc_t *vdc, size_t dsk_size, size_t blk_size, size_t xfr_size)
8199 {
8200 vd_err_stats_t *stp;
8201
8202 ASSERT(MUTEX_HELD(&vdc->lock));
8203 ASSERT(xfr_size != 0);
8204
8205 /*
8206 * If the disk size is unknown or sizes are unchanged then don't
8207 * update anything.
8208 */
8209 if (dsk_size == VD_SIZE_UNKNOWN || dsk_size == 0 ||
8210 (blk_size == vdc->vdisk_bsize && dsk_size == vdc->vdisk_size &&
8211 xfr_size == vdc->max_xfer_sz))
8212 return;
8213
8214 /*
8215 * We don't know at compile time what the vDisk server will think
8216 * are good values but we apply a large (arbitrary) upper bound to
8217 * prevent memory exhaustion in vdc if it was allocating a DRing
8218 * based of huge values sent by the server. We probably will never
8219 * exceed this except if the message was garbage.
8220 */
8221 if ((xfr_size * blk_size) > (PAGESIZE * DEV_BSIZE)) {
8222 DMSG(vdc, 0, "[%d] vds block transfer size too big;"
8223 " using max supported by vdc", vdc->instance);
8224 xfr_size = maxphys / blk_size;
8225 }
8226
8227 vdc->max_xfer_sz = xfr_size;
8228 vdc->vdisk_bsize = blk_size;
8229 vdc->vdisk_size = dsk_size;
8230
8231 stp = (vd_err_stats_t *)vdc->err_stats->ks_data;
8232 stp->vd_capacity.value.ui64 = dsk_size * blk_size;
8233
8234 vdc->minfo->dki_capacity = dsk_size;
8235 vdc->minfo->dki_lbsize = (uint_t)blk_size;
8236 }
8237
8238 /*
8239 * Update information about the VIO block size. The VIO block size is the
8240 * same as the vdisk block size which is stored in vdc->vdisk_bsize so we
8241 * do not store that information again.
8242 *
8243 * However, buf structures will always use a logical block size of 512 bytes
8244 * (DEV_BSIZE) and we will need to convert logical block numbers to VIO block
8245 * numbers for each read or write operation using vdc_strategy(). To speed up
8246 * this conversion, we expect the VIO block size to be a power of 2 and a
8247 * multiple 512 bytes (DEV_BSIZE), and we cache some useful information.
8248 *
8249 * The function return EINVAL if the new VIO block size (blk_size) is not a
8250 * power of 2 or not a multiple of 512 bytes, otherwise it returns 0.
8251 */
8252 static int
8253 vdc_update_vio_bsize(vdc_t *vdc, uint32_t blk_size)
8254 {
8255 uint32_t ratio, n;
8256 int nshift = 0;
8257
8258 vdc->vio_bmask = 0;
8259 vdc->vio_bshift = 0;
8260
8261 ASSERT(blk_size > 0);
8262
8263 if ((blk_size % DEV_BSIZE) != 0)
8264 return (EINVAL);
8265
8266 ratio = blk_size / DEV_BSIZE;
8267
8268 for (n = ratio; n > 1; n >>= 1) {
8269 if ((n & 0x1) != 0) {
8270 /* blk_size is not a power of 2 */
8271 return (EINVAL);
8272 }
8273 nshift++;
8274 }
8275
8276 vdc->vio_bshift = nshift;
8277 vdc->vio_bmask = ratio - 1;
8278
8279 return (0);
8280 }
8281
8282 /*
8283 * Function:
8284 * vdc_validate_geometry
8285 *
8286 * Description:
8287 * This routine discovers the label and geometry of the disk. It stores
8288 * the disk label and related information in the vdc structure. If it
8289 * fails to validate the geometry or to discover the disk label then
8290 * the label is marked as unknown (VD_DISK_LABEL_UNK).
8291 *
8292 * Arguments:
8293 * vdc - soft state pointer for this instance of the device driver.
8294 *
8295 * Return Code:
8296 * 0 - success.
8297 * EINVAL - unknown disk label.
8298 * ENOTSUP - geometry not applicable (EFI label).
8299 * EIO - error accessing the disk.
8300 */
8301 static int
8302 vdc_validate_geometry(vdc_t *vdc)
8303 {
8304 dev_t dev;
8305 int rv, rval;
8306 struct dk_label *label;
8307 struct dk_geom geom;
8308 struct extvtoc vtoc;
8309 efi_gpt_t *gpt;
8310 efi_gpe_t *gpe;
8311 vd_efi_dev_t edev;
8312
8313 ASSERT(vdc != NULL);
8314 ASSERT(vdc->vtoc != NULL && vdc->geom != NULL);
8315 ASSERT(MUTEX_HELD(&vdc->lock));
8316
8317 mutex_exit(&vdc->lock);
8318 /*
8319 * Check the disk capacity in case it has changed. If that fails then
8320 * we proceed and we will be using the disk size we currently have.
8321 */
8322 (void) vdc_check_capacity(vdc);
8323 dev = makedevice(ddi_driver_major(vdc->dip),
8324 VD_MAKE_DEV(vdc->instance, 0));
8325
8326 rv = vd_process_ioctl(dev, DKIOCGGEOM, (caddr_t)&geom, FKIOCTL, &rval);
8327 if (rv == 0)
8328 rv = vd_process_ioctl(dev, DKIOCGEXTVTOC, (caddr_t)&vtoc,
8329 FKIOCTL, &rval);
8330
8331 if (rv == ENOTSUP) {
8332 /*
8333 * If the device does not support VTOC then we try
8334 * to read an EFI label.
8335 *
8336 * We need to know the block size and the disk size to
8337 * be able to read an EFI label.
8338 */
8339 if (vdc->vdisk_size == 0) {
8340 mutex_enter(&vdc->lock);
8341 vdc_store_label_unk(vdc);
8342 return (EIO);
8343 }
8344
8345 VDC_EFI_DEV_SET(edev, vdc, vd_process_efi_ioctl);
8346
8347 rv = vd_efi_alloc_and_read(&edev, &gpt, &gpe);
8348
8349 if (rv) {
8350 DMSG(vdc, 0, "[%d] Failed to get EFI (err=%d)",
8351 vdc->instance, rv);
8352 mutex_enter(&vdc->lock);
8353 vdc_store_label_unk(vdc);
8354 return (EIO);
8355 }
8356
8357 mutex_enter(&vdc->lock);
8358 vdc_store_label_efi(vdc, gpt, gpe);
8359 vd_efi_free(&edev, gpt, gpe);
8360 return (ENOTSUP);
8361 }
8362
8363 if (rv != 0) {
8364 DMSG(vdc, 0, "[%d] Failed to get VTOC (err=%d)",
8365 vdc->instance, rv);
8366 mutex_enter(&vdc->lock);
8367 vdc_store_label_unk(vdc);
8368 if (rv != EINVAL)
8369 rv = EIO;
8370 return (rv);
8371 }
8372
8373 /* check that geometry and vtoc are valid */
8374 if (geom.dkg_nhead == 0 || geom.dkg_nsect == 0 ||
8375 vtoc.v_sanity != VTOC_SANE) {
8376 mutex_enter(&vdc->lock);
8377 vdc_store_label_unk(vdc);
8378 return (EINVAL);
8379 }
8380
8381 /*
8382 * We have a disk and a valid VTOC. However this does not mean
8383 * that the disk currently have a VTOC label. The returned VTOC may
8384 * be a default VTOC to be used for configuring the disk (this is
8385 * what is done for disk image). So we read the label from the
8386 * beginning of the disk to ensure we really have a VTOC label.
8387 *
8388 * FUTURE: This could be the default way for reading the VTOC
8389 * from the disk as opposed to sending the VD_OP_GET_VTOC
8390 * to the server. This will be the default if vdc is implemented
8391 * ontop of cmlb.
8392 */
8393
8394 /*
8395 * Single slice disk does not support read using an absolute disk
8396 * offset so we just rely on the DKIOCGVTOC ioctl in that case.
8397 */
8398 if (vdc->vdisk_type == VD_DISK_TYPE_SLICE) {
8399 mutex_enter(&vdc->lock);
8400 if (vtoc.v_nparts != 1) {
8401 vdc_store_label_unk(vdc);
8402 return (EINVAL);
8403 }
8404 vdc_store_label_vtoc(vdc, &geom, &vtoc);
8405 return (0);
8406 }
8407
8408 if (vtoc.v_nparts != V_NUMPAR) {
8409 mutex_enter(&vdc->lock);
8410 vdc_store_label_unk(vdc);
8411 return (EINVAL);
8412 }
8413
8414 /*
8415 * Most CD/DVDs do not have a disk label and the label is
8416 * generated by the disk driver. So the on-disk label check
8417 * below may fail and we return now to avoid this problem.
8418 */
8419 if (vdc->vdisk_media == VD_MEDIA_CD ||
8420 vdc->vdisk_media == VD_MEDIA_DVD) {
8421 mutex_enter(&vdc->lock);
8422 vdc_store_label_vtoc(vdc, &geom, &vtoc);
8423 return (0);
8424 }
8425
8426 /*
8427 * Read disk label from start of disk
8428 */
8429 label = kmem_alloc(vdc->vdisk_bsize, KM_SLEEP);
8430
8431 rv = vdc_do_op(vdc, VD_OP_BREAD, (caddr_t)label, vdc->vdisk_bsize,
8432 VD_SLICE_NONE, 0, NULL, VIO_read_dir, VDC_OP_NORMAL);
8433
8434 if (rv != 0 || label->dkl_magic != DKL_MAGIC ||
8435 label->dkl_cksum != vdc_lbl2cksum(label)) {
8436 DMSG(vdc, 1, "[%d] Got VTOC with invalid label\n",
8437 vdc->instance);
8438 kmem_free(label, vdc->vdisk_bsize);
8439 mutex_enter(&vdc->lock);
8440 vdc_store_label_unk(vdc);
8441 return (EINVAL);
8442 }
8443
8444 kmem_free(label, vdc->vdisk_bsize);
8445 mutex_enter(&vdc->lock);
8446 vdc_store_label_vtoc(vdc, &geom, &vtoc);
8447 return (0);
8448 }
8449
8450 /*
8451 * Function:
8452 * vdc_validate
8453 *
8454 * Description:
8455 * This routine discovers the label of the disk and create the
8456 * appropriate device nodes if the label has changed.
8457 *
8458 * Arguments:
8459 * vdc - soft state pointer for this instance of the device driver.
8460 *
8461 * Return Code:
8462 * none.
8463 */
8464 static void
8465 vdc_validate(vdc_t *vdc)
8466 {
8467 vd_disk_label_t old_label;
8468 vd_slice_t old_slice[V_NUMPAR];
8469 int rv;
8470
8471 ASSERT(!MUTEX_HELD(&vdc->lock));
8472
8473 mutex_enter(&vdc->lock);
8474
8475 /* save the current label and vtoc */
8476 old_label = vdc->vdisk_label;
8477 bcopy(vdc->slice, &old_slice, sizeof (vd_slice_t) * V_NUMPAR);
8478
8479 /* check the geometry */
8480 (void) vdc_validate_geometry(vdc);
8481
8482 /* if the disk label has changed, update device nodes */
8483 if (vdc->vdisk_type == VD_DISK_TYPE_DISK &&
8484 vdc->vdisk_label != old_label) {
8485
8486 if (vdc->vdisk_label == VD_DISK_LABEL_EFI)
8487 rv = vdc_create_device_nodes_efi(vdc);
8488 else
8489 rv = vdc_create_device_nodes_vtoc(vdc);
8490
8491 if (rv != 0) {
8492 DMSG(vdc, 0, "![%d] Failed to update device nodes",
8493 vdc->instance);
8494 }
8495 }
8496
8497 mutex_exit(&vdc->lock);
8498 }
8499
8500 static void
8501 vdc_validate_task(void *arg)
8502 {
8503 vdc_t *vdc = (vdc_t *)arg;
8504
8505 vdc_validate(vdc);
8506
8507 mutex_enter(&vdc->lock);
8508 ASSERT(vdc->validate_pending > 0);
8509 vdc->validate_pending--;
8510 mutex_exit(&vdc->lock);
8511 }
8512
8513 /*
8514 * Function:
8515 * vdc_setup_devid()
8516 *
8517 * Description:
8518 * This routine discovers the devid of a vDisk. It requests the devid of
8519 * the underlying device from the vDisk server, builds an encapsulated
8520 * devid based on the retrieved devid and registers that new devid to
8521 * the vDisk.
8522 *
8523 * Arguments:
8524 * vdc - soft state pointer for this instance of the device driver.
8525 *
8526 * Return Code:
8527 * 0 - A devid was succesfully registered for the vDisk
8528 */
8529 static int
8530 vdc_setup_devid(vdc_t *vdc)
8531 {
8532 int rv;
8533 vd_devid_t *vd_devid;
8534 size_t bufsize, bufid_len;
8535 ddi_devid_t vdisk_devid;
8536 char *devid_str;
8537
8538 /*
8539 * At first sight, we don't know the size of the devid that the
8540 * server will return but this size will be encoded into the
8541 * reply. So we do a first request using a default size then we
8542 * check if this size was large enough. If not then we do a second
8543 * request with the correct size returned by the server. Note that
8544 * ldc requires size to be 8-byte aligned.
8545 */
8546 bufsize = P2ROUNDUP(VD_DEVID_SIZE(VD_DEVID_DEFAULT_LEN),
8547 sizeof (uint64_t));
8548 vd_devid = kmem_zalloc(bufsize, KM_SLEEP);
8549 bufid_len = bufsize - sizeof (vd_efi_t) - 1;
8550
8551 rv = vdc_do_op(vdc, VD_OP_GET_DEVID, (caddr_t)vd_devid,
8552 bufsize, 0, 0, NULL, VIO_both_dir, 0);
8553
8554 DMSG(vdc, 2, "do_op returned %d\n", rv);
8555
8556 if (rv) {
8557 kmem_free(vd_devid, bufsize);
8558 return (rv);
8559 }
8560
8561 if (vd_devid->length > bufid_len) {
8562 /*
8563 * The returned devid is larger than the buffer used. Try again
8564 * with a buffer with the right size.
8565 */
8566 kmem_free(vd_devid, bufsize);
8567 bufsize = P2ROUNDUP(VD_DEVID_SIZE(vd_devid->length),
8568 sizeof (uint64_t));
8569 vd_devid = kmem_zalloc(bufsize, KM_SLEEP);
8570 bufid_len = bufsize - sizeof (vd_efi_t) - 1;
8571
8572 rv = vdc_do_sync_op(vdc, VD_OP_GET_DEVID, (caddr_t)vd_devid,
8573 bufsize, 0, 0, VIO_both_dir, B_TRUE);
8574
8575 if (rv) {
8576 kmem_free(vd_devid, bufsize);
8577 return (rv);
8578 }
8579 }
8580
8581 /*
8582 * The virtual disk should have the same device id as the one associated
8583 * with the physical disk it is mapped on, otherwise sharing a disk
8584 * between a LDom and a non-LDom may not work (for example for a shared
8585 * SVM disk set).
8586 *
8587 * The DDI framework does not allow creating a device id with any
8588 * type so we first create a device id of type DEVID_ENCAP and then
8589 * we restore the orignal type of the physical device.
8590 */
8591
8592 DMSG(vdc, 2, ": devid length = %d\n", vd_devid->length);
8593
8594 /* build an encapsulated devid based on the returned devid */
8595 if (ddi_devid_init(vdc->dip, DEVID_ENCAP, vd_devid->length,
8596 vd_devid->id, &vdisk_devid) != DDI_SUCCESS) {
8597 DMSG(vdc, 1, "[%d] Fail to created devid\n", vdc->instance);
8598 kmem_free(vd_devid, bufsize);
8599 return (1);
8600 }
8601
8602 DEVID_FORMTYPE((impl_devid_t *)vdisk_devid, vd_devid->type);
8603
8604 ASSERT(ddi_devid_valid(vdisk_devid) == DDI_SUCCESS);
8605
8606 kmem_free(vd_devid, bufsize);
8607
8608 if (vdc->devid != NULL) {
8609 /* check that the devid hasn't changed */
8610 if (ddi_devid_compare(vdisk_devid, vdc->devid) == 0) {
8611 ddi_devid_free(vdisk_devid);
8612 return (0);
8613 }
8614
8615 cmn_err(CE_WARN, "vdisk@%d backend devid has changed",
8616 vdc->instance);
8617
8618 devid_str = ddi_devid_str_encode(vdc->devid, NULL);
8619
8620 cmn_err(CE_CONT, "vdisk@%d backend initial devid: %s",
8621 vdc->instance,
8622 (devid_str)? devid_str : "<encoding error>");
8623
8624 if (devid_str)
8625 ddi_devid_str_free(devid_str);
8626
8627 devid_str = ddi_devid_str_encode(vdisk_devid, NULL);
8628
8629 cmn_err(CE_CONT, "vdisk@%d backend current devid: %s",
8630 vdc->instance,
8631 (devid_str)? devid_str : "<encoding error>");
8632
8633 if (devid_str)
8634 ddi_devid_str_free(devid_str);
8635
8636 ddi_devid_free(vdisk_devid);
8637 return (1);
8638 }
8639
8640 if (ddi_devid_register(vdc->dip, vdisk_devid) != DDI_SUCCESS) {
8641 DMSG(vdc, 1, "[%d] Fail to register devid\n", vdc->instance);
8642 ddi_devid_free(vdisk_devid);
8643 return (1);
8644 }
8645
8646 vdc->devid = vdisk_devid;
8647
8648 return (0);
8649 }
8650
8651 static void
8652 vdc_store_label_efi(vdc_t *vdc, efi_gpt_t *gpt, efi_gpe_t *gpe)
8653 {
8654 int i, nparts;
8655
8656 ASSERT(MUTEX_HELD(&vdc->lock));
8657
8658 vdc->vdisk_label = VD_DISK_LABEL_EFI;
8659 bzero(vdc->vtoc, sizeof (struct extvtoc));
8660 bzero(vdc->geom, sizeof (struct dk_geom));
8661 bzero(vdc->slice, sizeof (vd_slice_t) * V_NUMPAR);
8662
8663 nparts = gpt->efi_gpt_NumberOfPartitionEntries;
8664
8665 for (i = 0; i < nparts && i < VD_EFI_WD_SLICE; i++) {
8666
8667 if (gpe[i].efi_gpe_StartingLBA == 0 &&
8668 gpe[i].efi_gpe_EndingLBA == 0) {
8669 continue;
8670 }
8671
8672 vdc->slice[i].start = gpe[i].efi_gpe_StartingLBA;
8673 vdc->slice[i].nblocks = gpe[i].efi_gpe_EndingLBA -
8674 gpe[i].efi_gpe_StartingLBA + 1;
8675 }
8676
8677 ASSERT(vdc->vdisk_size != 0);
8678 vdc->slice[VD_EFI_WD_SLICE].start = 0;
8679 vdc->slice[VD_EFI_WD_SLICE].nblocks = vdc->vdisk_size;
8680
8681 }
8682
8683 static void
8684 vdc_store_label_vtoc(vdc_t *vdc, struct dk_geom *geom, struct extvtoc *vtoc)
8685 {
8686 int i;
8687
8688 ASSERT(MUTEX_HELD(&vdc->lock));
8689 ASSERT(vdc->vdisk_bsize == vtoc->v_sectorsz);
8690
8691 vdc->vdisk_label = VD_DISK_LABEL_VTOC;
8692 bcopy(vtoc, vdc->vtoc, sizeof (struct extvtoc));
8693 bcopy(geom, vdc->geom, sizeof (struct dk_geom));
8694 bzero(vdc->slice, sizeof (vd_slice_t) * V_NUMPAR);
8695
8696 for (i = 0; i < vtoc->v_nparts; i++) {
8697 vdc->slice[i].start = vtoc->v_part[i].p_start;
8698 vdc->slice[i].nblocks = vtoc->v_part[i].p_size;
8699 }
8700 }
8701
8702 static void
8703 vdc_store_label_unk(vdc_t *vdc)
8704 {
8705 ASSERT(MUTEX_HELD(&vdc->lock));
8706
8707 vdc->vdisk_label = VD_DISK_LABEL_UNK;
8708 bzero(vdc->vtoc, sizeof (struct extvtoc));
8709 bzero(vdc->geom, sizeof (struct dk_geom));
8710 bzero(vdc->slice, sizeof (vd_slice_t) * V_NUMPAR);
8711 }
Unleashed OS