1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
23 */
24
25 /*
26 * XXX TODO
27 * #includes cribbed from stmf.c -- undoubtedly only a small subset of these
28 * are actually needed.
29 */
30 #include <sys/conf.h>
31 #include <sys/file.h>
32 #include <sys/ddi.h>
33 #include <sys/sunddi.h>
34 #include <sys/scsi/scsi.h>
35 #include <sys/scsi/generic/persist.h>
36 #include <sys/byteorder.h>
37 #include <sys/nvpair.h>
38 #include <sys/door.h>
39
40 #include <sys/stmf.h>
41 #include <sys/lpif.h>
42 #include <sys/stmf_ioctl.h>
43 #include <sys/portif.h>
44 #include <sys/pppt_ic_if.h>
45
46 #include "pppt.h"
47
48 /*
49 * Macros
50 */
51
52 /* Free a struct if it was allocated */
53 #define FREE_IF_ALLOC(m) \
54 do { \
55 if ((m)) kmem_free((m), sizeof (*(m))); \
56 _NOTE(CONSTCOND) \
57 } while (0)
58
59 /*
60 * Macros to simplify the addition of struct fields to an nvlist.
61 * The name of the fields in the nvlist is the same as the name
62 * of the struct field.
63 *
64 * These macros require an int rc and a "done:" return retval label;
65 * they assume that the nvlist is named "nvl".
66 */
67 #define NVLIST_ADD_FIELD(type, structure, field) \
68 do { \
69 rc = nvlist_add_##type(nvl, #field, structure->field); \
70 if (rc) goto done; \
71 _NOTE(CONSTCOND) \
72 } while (0)
73
74 /* use this macro when the array is defined as part of the struct */
75 #define NVLIST_ADD_ARRAY(type, structure, field) \
76 do { \
77 rc = nvlist_add_##type##_array(nvl, #field, \
78 structure->field, sizeof (structure->field)); \
79 if (rc) goto done; \
80 _NOTE(CONSTCOND) \
81 } while (0)
82
83 /*
84 * use this macro when the array field is a ptr or you need to explictly
85 * call out the size.
86 */
87 #define NVLIST_ADD_ARRAY_LEN(type, structure, field, len) \
88 do { \
89 rc = nvlist_add_##type##_array(nvl, #field, \
90 structure->field, len); \
91 if (rc) goto done; \
92 _NOTE(CONSTCOND) \
93 } while (0)
94
95 #define NVLIST_ADD_DEVID(structure, field) \
96 do { \
97 rc = stmf_ic_scsi_devid_desc_marshal(nvl, #field, \
98 structure->field); \
99 if (rc) goto done; \
100 _NOTE(CONSTCOND) \
101 } while (0)
102
103 #define NVLIST_ADD_RPORT(structure, field) \
104 do { \
105 rc = stmf_ic_remote_port_marshal(nvl, #field, \
106 structure->field); \
107 if (rc) goto done; \
108 _NOTE(CONSTCOND) \
109 } while (0)
110
111 #define NVLIST_ADD_FIELD_UINT8(structure, field) \
112 NVLIST_ADD_FIELD(structure, field, uint8)
113
114 /*
115 * Macros to simplify the extraction of struct fields from an nvlist.
116 * The name of the fields in the nvlist is the same as the name
117 * of the struct field.
118 *
119 * Requires an int rc and a "done:" return retval label.
120 * Assumes that the nvlist is named "nvl".
121 *
122 * Sample usage: NVLIST_LOOKUP_FIELD(uint8, structname, fieldname);
123 */
124 #define NVLIST_LOOKUP_FIELD(type, structure, field) \
125 do { \
126 rc = nvlist_lookup_##type(nvl, #field, \
127 &(structure->field)); \
128 if (rc) { \
129 stmf_ic_nvlookup_warn(__func__, #field); \
130 goto done; \
131 } \
132 _NOTE(CONSTCOND) \
133 } while (0)
134
135 /*
136 * Look up a field which gets stored into a structure bit field.
137 * The type passed is a uint type which can hold the largest value
138 * in the bit field.
139 *
140 * Requires an int rc and a "done:" return retval label.
141 * Assumes that the nvlist is named "nvl".
142 *
143 * Sample usage: NVLIST_LOOKUP_BIT_FIELD(uint8, structname, fieldname);
144 */
145 #define NVLIST_LOOKUP_BIT_FIELD(type, structure, field) \
146 do { \
147 type##_t tmp; \
148 rc = nvlist_lookup_##type(nvl, #field, &tmp); \
149 if (rc) { \
150 stmf_ic_nvlookup_warn(__func__, #field); \
151 goto done; \
152 } \
153 structure->field = tmp; \
154 _NOTE(CONSTCOND) \
155 } while (0)
156
157 /*
158 * Look up a boolean field which gets stored into a structure bit field.
159 *
160 * Requires an int rc and a "done:" return retval label.
161 * Assumes that the nvlist is named "nvl".
162 */
163 #define NVLIST_LOOKUP_BIT_FIELD_BOOLEAN(structure, field) \
164 do { \
165 boolean_t tmp; \
166 rc = nvlist_lookup_boolean_value(nvl, #field, &tmp); \
167 if (rc) { \
168 stmf_ic_nvlookup_warn(__func__, #field); \
169 goto done; \
170 } \
171 structure->field = (tmp ? 1 : 0); \
172 _NOTE(CONSTCOND) \
173 } while (0)
174
175 /* shorthand for nvlist_lookup_pairs() args */
176 #define NV_PAIR(type, strct, field) #field, DATA_TYPE_##type, &(strct->field)
177
178 /* number of times to retry the upcall to transmit */
179 #define STMF_MSG_TRANSMIT_RETRY 3
180
181 /*
182 * How was the message constructed?
183 *
184 * We need to know this when we free the message in order to
185 * determine what to do with pointers in the message:
186 *
187 * - messages which were unmarshaled from an nvlist may point to
188 * memory within that nvlist; this memory should not be freed since
189 * it will be deallocated when we free the nvlist.
190 *
191 * - messages which built using a constructor (alloc) function may
192 * point to memory which was explicitly allocated by the constructor;
193 * it should be freed when the message is freed.
194 *
195 */
196 typedef enum {
197 STMF_CONSTRUCTOR = 0,
198 STMF_UNMARSHAL
199 } stmf_ic_msg_construction_method_t;
200
201
202 /*
203 * Function prototypes.
204 */
205
206 /*
207 * Helpers for msg_alloc routines, used when the msg payload is
208 * the same for multiple types of messages.
209 */
210 static stmf_ic_msg_t *stmf_ic_reg_dereg_lun_msg_alloc(
211 stmf_ic_msg_type_t msg_type, uint8_t *lun_id,
212 char *lu_provider_name, uint16_t cb_arg_len,
213 uint8_t *cb_arg, stmf_ic_msgid_t msgid);
214
215 static stmf_ic_msg_t *stmf_ic_session_create_destroy_msg_alloc(
216 stmf_ic_msg_type_t msg_type,
217 stmf_scsi_session_t *session,
218 stmf_ic_msgid_t msgid);
219
220 static stmf_ic_msg_t *stmf_ic_echo_request_reply_msg_alloc(
221 stmf_ic_msg_type_t msg_type,
222 uint32_t data_len,
223 uint8_t *data,
224 stmf_ic_msgid_t msgid);
225
226 /*
227 * Msg free routines.
228 */
229 static void stmf_ic_reg_port_msg_free(stmf_ic_reg_port_msg_t *m,
230 stmf_ic_msg_construction_method_t cmethod);
231 static void stmf_ic_dereg_port_msg_free(stmf_ic_dereg_port_msg_t *m,
232 stmf_ic_msg_construction_method_t cmethod);
233 static void stmf_ic_reg_dereg_lun_msg_free(stmf_ic_reg_dereg_lun_msg_t *m,
234 stmf_ic_msg_construction_method_t cmethod);
235 static void stmf_ic_scsi_cmd_msg_free(stmf_ic_scsi_cmd_msg_t *m,
236 stmf_ic_msg_construction_method_t cmethod);
237 static void stmf_ic_scsi_data_msg_free(stmf_ic_scsi_data_msg_t *m,
238 stmf_ic_msg_construction_method_t cmethod);
239 static void stmf_ic_scsi_data_xfer_done_msg_free(
240 stmf_ic_scsi_data_xfer_done_msg_t *m,
241 stmf_ic_msg_construction_method_t cmethod);
242 static void stmf_ic_scsi_status_msg_free(stmf_ic_scsi_status_msg_t *m,
243 stmf_ic_msg_construction_method_t cmethod);
244 static void stmf_ic_r2t_msg_free(stmf_ic_r2t_msg_t *m,
245 stmf_ic_msg_construction_method_t cmethod);
246 static void stmf_ic_status_msg_free(stmf_ic_status_msg_t *m,
247 stmf_ic_msg_construction_method_t cmethod);
248 static void stmf_ic_session_create_destroy_msg_free(
249 stmf_ic_session_create_destroy_msg_t *m,
250 stmf_ic_msg_construction_method_t cmethod);
251 static void stmf_ic_echo_request_reply_msg_free(
252 stmf_ic_echo_request_reply_msg_t *m,
253 stmf_ic_msg_construction_method_t cmethod);
254
255 /*
256 * Marshaling routines.
257 */
258 static nvlist_t *stmf_ic_msg_marshal(stmf_ic_msg_t *msg);
259 static int stmf_ic_reg_port_msg_marshal(nvlist_t *nvl, void *msg);
260 static int stmf_ic_dereg_port_msg_marshal(nvlist_t *nvl, void *msg);
261 static int stmf_ic_reg_dereg_lun_msg_marshal(nvlist_t *nvl, void *msg);
262 static int stmf_ic_scsi_cmd_msg_marshal(nvlist_t *nvl, void *msg);
263 static int stmf_ic_scsi_data_msg_marshal(nvlist_t *nvl, void *msg);
264 static int stmf_ic_scsi_data_xfer_done_msg_marshal(nvlist_t *nvl, void *msg);
265 static int stmf_ic_scsi_status_msg_marshal(nvlist_t *nvl, void *msg);
266 static int stmf_ic_r2t_msg_marshal(nvlist_t *nvl, void *msg);
267 static int stmf_ic_status_msg_marshal(nvlist_t *nvl, void *msg);
268 static int stmf_ic_session_create_destroy_msg_marshal(nvlist_t *nvl, void *msg);
269 static int stmf_ic_echo_request_reply_msg_marshal(nvlist_t *nvl, void *msg);
270 static int stmf_ic_scsi_devid_desc_marshal(nvlist_t *parent_nvl,
271 char *sdid_name, scsi_devid_desc_t *sdid);
272 static int stmf_ic_remote_port_marshal(nvlist_t *parent_nvl,
273 char *rport_name, stmf_remote_port_t *rport);
274
275 /*
276 * Unmarshaling routines.
277 */
278 static stmf_ic_msg_t *stmf_ic_msg_unmarshal(nvlist_t *nvl);
279 static void *stmf_ic_reg_port_msg_unmarshal(nvlist_t *nvl);
280 static void *stmf_ic_dereg_port_msg_unmarshal(nvlist_t *nvl);
281 static void *stmf_ic_reg_dereg_lun_msg_unmarshal(nvlist_t *nvl);
282 static void *stmf_ic_scsi_cmd_msg_unmarshal(nvlist_t *nvl);
283 static void *stmf_ic_scsi_data_msg_unmarshal(nvlist_t *nvl);
284 static void *stmf_ic_scsi_data_xfer_done_msg_unmarshal(nvlist_t *nvl);
285 static void *stmf_ic_scsi_status_msg_unmarshal(nvlist_t *nvl);
286 static void *stmf_ic_r2t_msg_unmarshal(nvlist_t *nvl);
287 static void *stmf_ic_status_msg_unmarshal(nvlist_t *nvl);
288 static void *stmf_ic_session_create_destroy_msg_unmarshal(nvlist_t *nvl);
289 static void *stmf_ic_echo_request_reply_msg_unmarshal(nvlist_t *nvl);
290 static scsi_devid_desc_t *stmf_ic_lookup_scsi_devid_desc_and_unmarshal(
291 nvlist_t *nvl, char *field_name);
292 static scsi_devid_desc_t *stmf_ic_scsi_devid_desc_unmarshal(
293 nvlist_t *nvl_devid);
294 static uint8_t *stmf_ic_uint8_array_unmarshal(nvlist_t *nvl, char *field_name,
295 uint64_t len, uint8_t *buf);
296 static char *stmf_ic_string_unmarshal(nvlist_t *nvl, char *field_name);
297 static stmf_remote_port_t *stmf_ic_lookup_remote_port_and_unmarshal(
298 nvlist_t *nvl, char *field_name);
299 static stmf_remote_port_t *stmf_ic_remote_port_unmarshal(nvlist_t *nvl);
300
301 /*
302 * Transmit and recieve routines.
303 */
304 stmf_ic_msg_status_t stmf_ic_transmit(char *buf, size_t size);
305
306 /*
307 * Utilities.
308 */
309 static stmf_ic_msg_t *stmf_ic_alloc_msg_header(stmf_ic_msg_type_t msg_type,
310 stmf_ic_msgid_t msgid);
311 static size_t sizeof_scsi_devid_desc(int ident_length);
312 static char *stmf_ic_strdup(char *str);
313 static scsi_devid_desc_t *scsi_devid_desc_dup(scsi_devid_desc_t *did);
314 static stmf_remote_port_t *remote_port_dup(stmf_remote_port_t *rport);
315 static void scsi_devid_desc_free(scsi_devid_desc_t *did);
316 static inline void stmf_ic_nvlookup_warn(const char *func, char *field);
317
318 /*
319 * Send a message out over the interconnect, in the process marshalling
320 * the arguments.
321 *
322 * After being sent, the message is freed.
323 */
324 stmf_ic_msg_status_t
325 stmf_ic_tx_msg(stmf_ic_msg_t *msg)
326 {
327 size_t size = 0;
328 nvlist_t *nvl = NULL;
329 char *buf = NULL;
330 int err = 0;
331 stmf_ic_msg_status_t status = STMF_IC_MSG_SUCCESS;
332
333 nvl = stmf_ic_msg_marshal(msg);
334 if (!nvl) {
335 cmn_err(CE_WARN, "stmf_ic_tx_msg: marshal failed");
336 status = STMF_IC_MSG_INTERNAL_ERROR;
337 goto done;
338 }
339
340 err = nvlist_size(nvl, &size, NV_ENCODE_XDR);
341 if (err) {
342 status = STMF_IC_MSG_INTERNAL_ERROR;
343 goto done;
344 }
345
346 buf = kmem_alloc(size, KM_SLEEP);
347 err = nvlist_pack(nvl, &buf, &size, NV_ENCODE_XDR, 0);
348 if (err) {
349 status = STMF_IC_MSG_INTERNAL_ERROR;
350 goto done;
351 }
352
353 /* push the bits out on the wire */
354
355 status = stmf_ic_transmit(buf, size);
356
357 done:
358 nvlist_free(nvl);
359
360 if (buf)
361 kmem_free(buf, size);
362
363 stmf_ic_msg_free(msg);
364
365
366 return (status);
367 }
368
369 /*
370 * Pass the command to the daemon for transmission to the other node.
371 */
372 stmf_ic_msg_status_t
373 stmf_ic_transmit(char *buf, size_t size)
374 {
375 int i;
376 int rc;
377 door_arg_t arg;
378 door_handle_t door;
379 uint32_t result;
380
381 mutex_enter(&pppt_global.global_door_lock);
382 if (pppt_global.global_door == NULL) {
383 /* daemon not listening */
384 mutex_exit(&pppt_global.global_door_lock);
385 return (STMF_IC_MSG_INTERNAL_ERROR);
386 }
387 door = pppt_global.global_door;
388 door_ki_hold(door);
389 mutex_exit(&pppt_global.global_door_lock);
390
391 arg.data_ptr = buf;
392 arg.data_size = size;
393 arg.desc_ptr = NULL;
394 arg.desc_num = 0;
395 arg.rbuf = (char *)&result;
396 arg.rsize = sizeof (result);
397 /*
398 * Retry a few times if there is a shortage of threads to
399 * service the upcall. This shouldn't happen unless a large
400 * number of initiators issue commands at once.
401 */
402 for (i = 0; i < STMF_MSG_TRANSMIT_RETRY; i++) {
403 rc = door_ki_upcall(door, &arg);
404 if (rc != EAGAIN)
405 break;
406 delay(hz);
407 }
408 door_ki_rele(door);
409 if (rc != 0) {
410 cmn_err(CE_WARN,
411 "stmf_ic_transmit door_ki_upcall failed %d", rc);
412 return (STMF_IC_MSG_INTERNAL_ERROR);
413 }
414 if (result != 0) {
415 /* XXX Just warn for now */
416 cmn_err(CE_WARN,
417 "stmf_ic_transmit bad result from daemon %d", result);
418 }
419
420 return (STMF_IC_MSG_SUCCESS);
421 }
422
423 /*
424 * This is a low-level upcall which is called when a message has
425 * been received on the interconnect.
426 *
427 * The caller is responsible for freeing the buffer which is passed in.
428 */
429 /*ARGSUSED*/
430 void
431 stmf_ic_rx_msg(char *buf, size_t len)
432 {
433 nvlist_t *nvl = NULL;
434 stmf_ic_msg_t *m = NULL;
435 stmf_ic_echo_request_reply_msg_t *icerr;
436 stmf_ic_msg_t *echo_msg;
437 int rc = 0;
438
439 rc = nvlist_unpack(buf, len, &nvl, 0);
440 if (rc) {
441 cmn_err(CE_WARN, "stmf_ic_rx_msg: unpack failed");
442 return;
443 }
444
445 m = stmf_ic_msg_unmarshal(nvl);
446 if (m == NULL) {
447 cmn_err(CE_WARN, "stmf_ic_rx_msg: unmarshal failed");
448 nvlist_free(nvl);
449 return;
450 }
451
452 switch (m->icm_msg_type) {
453
454 case STMF_ICM_REGISTER_PROXY_PORT:
455 case STMF_ICM_DEREGISTER_PROXY_PORT:
456 case STMF_ICM_SCSI_CMD:
457 case STMF_ICM_SCSI_DATA_XFER_DONE:
458 case STMF_ICM_SESSION_CREATE:
459 case STMF_ICM_SESSION_DESTROY:
460 /*
461 * These messages are all received by pppt.
462 * Currently, pppt will parse the message for type
463 */
464 (void) pppt_msg_rx(m);
465 break;
466
467 case STMF_ICM_LUN_ACTIVE:
468 case STMF_ICM_REGISTER_LUN:
469 case STMF_ICM_DEREGISTER_LUN:
470 case STMF_ICM_SCSI_DATA:
471 case STMF_ICM_SCSI_STATUS:
472 /*
473 * These messages are all received by stmf.
474 * Currently, stmf will parse the message for type
475 */
476 (void) stmf_msg_rx(m);
477 break;
478
479 case STMF_ICM_ECHO_REQUEST:
480 icerr = m->icm_msg;
481 echo_msg = stmf_ic_echo_reply_msg_alloc(icerr->icerr_datalen,
482 icerr->icerr_data, 0);
483 if (echo_msg != NULL) {
484 (void) stmf_ic_tx_msg(echo_msg);
485 }
486 stmf_ic_msg_free(m);
487 break;
488
489 case STMF_ICM_ECHO_REPLY:
490 stmf_ic_msg_free(m);
491 break;
492
493 case STMF_ICM_R2T:
494 /*
495 * XXX currently not supported
496 */
497 stmf_ic_msg_free(m);
498 break;
499
500 case STMF_ICM_STATUS:
501 (void) stmf_msg_rx(m);
502 break;
503
504 default:
505 ASSERT(0);
506 }
507 }
508
509 /*
510 * IC message allocation routines.
511 */
512
513 stmf_ic_msg_t *
514 stmf_ic_reg_port_msg_alloc(
515 scsi_devid_desc_t *port_id,
516 uint16_t relative_port_id,
517 uint16_t cb_arg_len,
518 uint8_t *cb_arg,
519 stmf_ic_msgid_t msgid)
520 {
521 stmf_ic_msg_t *icm = NULL;
522 stmf_ic_reg_port_msg_t *icrp = NULL;
523
524 icm = stmf_ic_alloc_msg_header(STMF_ICM_REGISTER_PROXY_PORT, msgid);
525 icrp = (stmf_ic_reg_port_msg_t *)kmem_zalloc(sizeof (*icrp), KM_SLEEP);
526 icm->icm_msg = (void *)icrp;
527
528 icrp->icrp_port_id = scsi_devid_desc_dup(port_id);
529 icrp->icrp_relative_port_id = relative_port_id;
530
531 if (cb_arg_len) {
532 icrp->icrp_cb_arg_len = cb_arg_len;
533 icrp->icrp_cb_arg = cb_arg;
534 }
535
536 return (icm);
537 }
538
539 stmf_ic_msg_t *
540 stmf_ic_dereg_port_msg_alloc(
541 scsi_devid_desc_t *port_id,
542 uint16_t cb_arg_len,
543 uint8_t *cb_arg,
544 stmf_ic_msgid_t msgid)
545 {
546 stmf_ic_msg_t *icm = NULL;
547 stmf_ic_dereg_port_msg_t *icdp = NULL;
548
549 icm = stmf_ic_alloc_msg_header(STMF_ICM_DEREGISTER_PROXY_PORT, msgid);
550 icdp = (stmf_ic_dereg_port_msg_t *)kmem_zalloc(sizeof (*icdp),
551 KM_SLEEP);
552 icm->icm_msg = (void *)icdp;
553
554 icdp->icdp_port_id = scsi_devid_desc_dup(port_id);
555
556 if (cb_arg_len) {
557 icdp->icdp_cb_arg_len = cb_arg_len;
558 icdp->icdp_cb_arg = cb_arg;
559 }
560
561 return (icm);
562 }
563
564
565 stmf_ic_msg_t *
566 stmf_ic_reg_lun_msg_alloc(
567 uint8_t *lun_id,
568 char *lu_provider_name,
569 uint16_t cb_arg_len,
570 uint8_t *cb_arg,
571 stmf_ic_msgid_t msgid)
572 {
573 return (stmf_ic_reg_dereg_lun_msg_alloc(STMF_ICM_REGISTER_LUN, lun_id,
574 lu_provider_name, cb_arg_len, cb_arg, msgid));
575 }
576
577 stmf_ic_msg_t *
578 stmf_ic_lun_active_msg_alloc(
579 uint8_t *lun_id,
580 char *lu_provider_name,
581 uint16_t cb_arg_len,
582 uint8_t *cb_arg,
583 stmf_ic_msgid_t msgid)
584 {
585 return (stmf_ic_reg_dereg_lun_msg_alloc(STMF_ICM_LUN_ACTIVE, lun_id,
586 lu_provider_name, cb_arg_len, cb_arg, msgid));
587 }
588
589 stmf_ic_msg_t *
590 stmf_ic_dereg_lun_msg_alloc(
591 uint8_t *lun_id,
592 char *lu_provider_name,
593 uint16_t cb_arg_len,
594 uint8_t *cb_arg,
595 stmf_ic_msgid_t msgid)
596 {
597 return (stmf_ic_reg_dereg_lun_msg_alloc(STMF_ICM_DEREGISTER_LUN, lun_id,
598 lu_provider_name, cb_arg_len, cb_arg, msgid));
599 }
600
601 /*
602 * Guts of lun register/deregister/active alloc routines.
603 */
604 static stmf_ic_msg_t *
605 stmf_ic_reg_dereg_lun_msg_alloc(
606 stmf_ic_msg_type_t msg_type,
607 uint8_t *lun_id,
608 char *lu_provider_name,
609 uint16_t cb_arg_len,
610 uint8_t *cb_arg,
611 stmf_ic_msgid_t msgid)
612 {
613 stmf_ic_msg_t *icm = NULL;
614 stmf_ic_reg_dereg_lun_msg_t *icrl = NULL;
615
616 icm = stmf_ic_alloc_msg_header(msg_type, msgid);
617 icrl = (stmf_ic_reg_dereg_lun_msg_t *)
618 kmem_zalloc(sizeof (*icrl), KM_SLEEP);
619 icm->icm_msg = (void *)icrl;
620
621 icrl->icrl_lu_provider_name = stmf_ic_strdup(lu_provider_name);
622
623 bcopy(lun_id, icrl->icrl_lun_id, sizeof (icrl->icrl_lun_id));
624
625 if (cb_arg_len) {
626 icrl->icrl_cb_arg_len = cb_arg_len;
627 icrl->icrl_cb_arg = cb_arg;
628 }
629
630 return (icm);
631 }
632
633 stmf_ic_msg_t *
634 stmf_ic_scsi_cmd_msg_alloc(
635 stmf_ic_msgid_t task_msgid,
636 scsi_task_t *task,
637 uint32_t immed_data_len,
638 uint8_t *immed_data,
639 stmf_ic_msgid_t msgid)
640 {
641 stmf_ic_msg_t *icm = NULL;
642 stmf_ic_scsi_cmd_msg_t *icsc = NULL;
643 scsi_devid_desc_t *ini_devid = task->task_session->ss_rport_id;
644 scsi_devid_desc_t *tgt_devid = task->task_lport->lport_id;
645 stmf_remote_port_t *rport = task->task_session->ss_rport;
646
647 icm = stmf_ic_alloc_msg_header(STMF_ICM_SCSI_CMD, msgid);
648 icsc = (stmf_ic_scsi_cmd_msg_t *)kmem_zalloc(sizeof (*icsc), KM_SLEEP);
649 icm->icm_msg = (void *)icsc;
650
651 icsc->icsc_task_msgid = task_msgid;
652 icsc->icsc_ini_devid = scsi_devid_desc_dup(ini_devid);
653 icsc->icsc_tgt_devid = scsi_devid_desc_dup(tgt_devid);
654 icsc->icsc_rport = remote_port_dup(rport);
655 icsc->icsc_session_id = task->task_session->ss_session_id;
656
657 if (!task->task_mgmt_function && task->task_lu->lu_id) {
658 bcopy(task->task_lu->lu_id->ident,
659 icsc->icsc_lun_id, sizeof (icsc->icsc_lun_id));
660 }
661
662 bcopy(task->task_lun_no, icsc->icsc_task_lun_no,
663 sizeof (icsc->icsc_task_lun_no));
664
665 icsc->icsc_task_expected_xfer_length = task->task_expected_xfer_length;
666 if (task->task_cdb_length) {
667 ASSERT(task->task_mgmt_function == TM_NONE);
668 icsc->icsc_task_cdb_length = task->task_cdb_length;
669 icsc->icsc_task_cdb =
670 (uint8_t *)kmem_zalloc(task->task_cdb_length, KM_SLEEP);
671 bcopy(task->task_cdb, icsc->icsc_task_cdb,
672 task->task_cdb_length);
673 }
674
675 icsc->icsc_task_flags = task->task_flags;
676 icsc->icsc_task_priority = task->task_priority;
677 icsc->icsc_task_mgmt_function = task->task_mgmt_function;
678
679 icsc->icsc_immed_data_len = immed_data_len;
680 icsc->icsc_immed_data = immed_data;
681
682 return (icm);
683 }
684
685 stmf_ic_msg_t *
686 stmf_ic_scsi_data_msg_alloc(
687 stmf_ic_msgid_t task_msgid,
688 uint64_t session_id,
689 uint8_t *lun_id,
690 uint64_t data_len,
691 uint8_t *data,
692 stmf_ic_msgid_t msgid)
693 {
694 stmf_ic_msg_t *icm = NULL;
695 stmf_ic_scsi_data_msg_t *icsd = NULL;
696
697 icm = stmf_ic_alloc_msg_header(STMF_ICM_SCSI_DATA, msgid);
698 icsd = (stmf_ic_scsi_data_msg_t *)kmem_zalloc(sizeof (*icsd), KM_SLEEP);
699 icm->icm_msg = (void *)icsd;
700
701 icsd->icsd_task_msgid = task_msgid;
702 icsd->icsd_session_id = session_id;
703 bcopy(lun_id, icsd->icsd_lun_id, sizeof (icsd->icsd_lun_id));
704 icsd->icsd_data_len = data_len;
705 icsd->icsd_data = data;
706
707 return (icm);
708 }
709
710 stmf_ic_msg_t *
711 stmf_ic_scsi_data_xfer_done_msg_alloc(
712 stmf_ic_msgid_t task_msgid,
713 uint64_t session_id,
714 stmf_status_t status,
715 stmf_ic_msgid_t msgid)
716 {
717 stmf_ic_msg_t *icm = NULL;
718 stmf_ic_scsi_data_xfer_done_msg_t *icsx = NULL;
719
720 icm = stmf_ic_alloc_msg_header(STMF_ICM_SCSI_DATA_XFER_DONE, msgid);
721 icsx = (stmf_ic_scsi_data_xfer_done_msg_t *)kmem_zalloc(
722 sizeof (*icsx), KM_SLEEP);
723 icm->icm_msg = (void *)icsx;
724
725 icsx->icsx_task_msgid = task_msgid;
726 icsx->icsx_session_id = session_id;
727 icsx->icsx_status = status;
728
729 return (icm);
730 }
731
732 stmf_ic_msg_t *
733 stmf_ic_scsi_status_msg_alloc(
734 stmf_ic_msgid_t task_msgid,
735 uint64_t session_id,
736 uint8_t *lun_id,
737 uint8_t response,
738 uint8_t status,
739 uint8_t flags,
740 uint32_t resid,
741 uint8_t sense_len,
742 uint8_t *sense,
743 stmf_ic_msgid_t msgid)
744 {
745 stmf_ic_msg_t *icm = NULL;
746 stmf_ic_scsi_status_msg_t *icss = NULL;
747
748 icm = stmf_ic_alloc_msg_header(STMF_ICM_SCSI_STATUS, msgid);
749 icss = (stmf_ic_scsi_status_msg_t *)kmem_zalloc(sizeof (*icss),
750 KM_SLEEP);
751 icm->icm_msg = (void *)icss;
752
753 icss->icss_task_msgid = task_msgid;
754 icss->icss_session_id = session_id;
755 bcopy(lun_id, icss->icss_lun_id, sizeof (icss->icss_lun_id));
756 icss->icss_response = response;
757 icss->icss_status = status;
758 icss->icss_flags = flags;
759 icss->icss_resid = resid;
760 icss->icss_sense_len = sense_len;
761 icss->icss_sense = sense;
762
763 return (icm);
764 }
765
766 stmf_ic_msg_t *
767 stmf_ic_r2t_msg_alloc(
768 stmf_ic_msgid_t task_msgid,
769 uint64_t session_id,
770 uint32_t offset,
771 uint32_t length,
772 stmf_ic_msgid_t msgid)
773 {
774 stmf_ic_msg_t *icm = NULL;
775 stmf_ic_r2t_msg_t *icrt = NULL;
776
777 icm = stmf_ic_alloc_msg_header(STMF_ICM_R2T, msgid);
778 icrt = (stmf_ic_r2t_msg_t *)kmem_zalloc(sizeof (*icrt), KM_SLEEP);
779 icm->icm_msg = (void *)icrt;
780
781 icrt->icrt_task_msgid = task_msgid;
782 icrt->icrt_session_id = session_id;
783 icrt->icrt_offset = offset;
784 icrt->icrt_length = length;
785
786 return (icm);
787 }
788
789 stmf_ic_msg_t *
790 stmf_ic_status_msg_alloc(
791 stmf_status_t status,
792 stmf_ic_msg_type_t msg_type,
793 stmf_ic_msgid_t msgid)
794 {
795 stmf_ic_msg_t *icm = NULL;
796 stmf_ic_status_msg_t *ics = NULL;
797
798 icm = stmf_ic_alloc_msg_header(STMF_ICM_STATUS, msgid);
799 ics = (stmf_ic_status_msg_t *)kmem_zalloc(sizeof (*ics), KM_SLEEP);
800 icm->icm_msg = (void *)ics;
801
802 ics->ics_status = status;
803 ics->ics_msg_type = msg_type;
804 ics->ics_msgid = msgid; /* XXX same as msgid in header */
805
806 return (icm);
807 }
808
809 stmf_ic_msg_t *
810 stmf_ic_session_create_msg_alloc(
811 stmf_scsi_session_t *session,
812 stmf_ic_msgid_t msgid)
813 {
814 return (stmf_ic_session_create_destroy_msg_alloc(
815 STMF_ICM_SESSION_CREATE, session, msgid));
816 }
817
818 stmf_ic_msg_t *
819 stmf_ic_session_destroy_msg_alloc(
820 stmf_scsi_session_t *session,
821 stmf_ic_msgid_t msgid)
822 {
823 return (stmf_ic_session_create_destroy_msg_alloc(
824 STMF_ICM_SESSION_DESTROY, session, msgid));
825 }
826
827 /*
828 * Guts of session create/destroy routines.
829 */
830 static stmf_ic_msg_t *
831 stmf_ic_session_create_destroy_msg_alloc(
832 stmf_ic_msg_type_t msg_type,
833 stmf_scsi_session_t *session,
834 stmf_ic_msgid_t msgid)
835 {
836 stmf_ic_msg_t *icm = NULL;
837 stmf_ic_session_create_destroy_msg_t *icscd = NULL;
838 scsi_devid_desc_t *ini_devid = session->ss_rport_id;
839 scsi_devid_desc_t *tgt_devid = session->ss_lport->lport_id;
840
841 icm = stmf_ic_alloc_msg_header(msg_type, msgid);
842 icscd = (stmf_ic_session_create_destroy_msg_t *)
843 kmem_zalloc(sizeof (*icscd), KM_SLEEP);
844 icm->icm_msg = (void *)icscd;
845
846 icscd->icscd_session_id = session->ss_session_id;
847 icscd->icscd_ini_devid = scsi_devid_desc_dup(ini_devid);
848 icscd->icscd_tgt_devid = scsi_devid_desc_dup(tgt_devid);
849 icscd->icscd_rport = remote_port_dup(session->ss_rport);
850
851 return (icm);
852 }
853
854 stmf_ic_msg_t *
855 stmf_ic_echo_request_msg_alloc(
856 uint32_t data_len,
857 uint8_t *data,
858 stmf_ic_msgid_t msgid)
859 {
860 return (stmf_ic_echo_request_reply_msg_alloc(
861 STMF_ICM_ECHO_REQUEST, data_len, data, msgid));
862 }
863
864 stmf_ic_msg_t *
865 stmf_ic_echo_reply_msg_alloc(
866 uint32_t data_len,
867 uint8_t *data,
868 stmf_ic_msgid_t msgid)
869 {
870 return (stmf_ic_echo_request_reply_msg_alloc(
871 STMF_ICM_ECHO_REPLY, data_len, data, msgid));
872 }
873
874
875 static stmf_ic_msg_t *
876 stmf_ic_echo_request_reply_msg_alloc(
877 stmf_ic_msg_type_t msg_type,
878 uint32_t data_len,
879 uint8_t *data,
880 stmf_ic_msgid_t msgid)
881 {
882 stmf_ic_msg_t *icm = NULL;
883 stmf_ic_echo_request_reply_msg_t *icerr = NULL;
884
885 icm = stmf_ic_alloc_msg_header(msg_type, msgid);
886 icerr = kmem_zalloc(sizeof (*icerr), KM_SLEEP);
887 icm->icm_msg = (void *)icerr;
888
889 icerr->icerr_data = data;
890 icerr->icerr_datalen = data_len;
891
892 return (icm);
893 }
894
895 /*
896 * msg free routines.
897 */
898 void
899 stmf_ic_msg_free(stmf_ic_msg_t *msg)
900 {
901 stmf_ic_msg_construction_method_t cmethod =
902 (msg->icm_nvlist ? STMF_UNMARSHAL : STMF_CONSTRUCTOR);
903
904 switch (msg->icm_msg_type) {
905 case STMF_ICM_REGISTER_PROXY_PORT:
906 stmf_ic_reg_port_msg_free(
907 (stmf_ic_reg_port_msg_t *)msg->icm_msg, cmethod);
908 break;
909
910 case STMF_ICM_DEREGISTER_PROXY_PORT:
911 stmf_ic_dereg_port_msg_free(
912 (stmf_ic_dereg_port_msg_t *)msg->icm_msg, cmethod);
913 break;
914
915 case STMF_ICM_LUN_ACTIVE:
916 case STMF_ICM_REGISTER_LUN:
917 case STMF_ICM_DEREGISTER_LUN:
918 stmf_ic_reg_dereg_lun_msg_free(
919 (stmf_ic_reg_dereg_lun_msg_t *)msg->icm_msg, cmethod);
920 break;
921
922 case STMF_ICM_SCSI_CMD:
923 stmf_ic_scsi_cmd_msg_free(
924 (stmf_ic_scsi_cmd_msg_t *)msg->icm_msg, cmethod);
925 break;
926
927 case STMF_ICM_SCSI_DATA:
928 stmf_ic_scsi_data_msg_free(
929 (stmf_ic_scsi_data_msg_t *)msg->icm_msg, cmethod);
930 break;
931
932 case STMF_ICM_SCSI_DATA_XFER_DONE:
933 stmf_ic_scsi_data_xfer_done_msg_free(
934 (stmf_ic_scsi_data_xfer_done_msg_t *)msg->icm_msg, cmethod);
935 break;
936
937 case STMF_ICM_SCSI_STATUS:
938 stmf_ic_scsi_status_msg_free(
939 (stmf_ic_scsi_status_msg_t *)msg->icm_msg, cmethod);
940 break;
941
942 case STMF_ICM_R2T:
943 stmf_ic_r2t_msg_free(
944 (stmf_ic_r2t_msg_t *)msg->icm_msg, cmethod);
945 break;
946
947 case STMF_ICM_STATUS:
948 stmf_ic_status_msg_free(
949 (stmf_ic_status_msg_t *)msg->icm_msg, cmethod);
950 break;
951
952 case STMF_ICM_SESSION_CREATE:
953 case STMF_ICM_SESSION_DESTROY:
954 stmf_ic_session_create_destroy_msg_free(
955 (stmf_ic_session_create_destroy_msg_t *)msg->icm_msg,
956 cmethod);
957 break;
958
959 case STMF_ICM_ECHO_REQUEST:
960 case STMF_ICM_ECHO_REPLY:
961 stmf_ic_echo_request_reply_msg_free(
962 (stmf_ic_echo_request_reply_msg_t *)msg->icm_msg, cmethod);
963 break;
964
965 case STMF_ICM_MAX_MSG_TYPE:
966 ASSERT(0);
967 break;
968
969 default:
970 ASSERT(0);
971 }
972
973 nvlist_free(msg->icm_nvlist);
974
975 kmem_free(msg, sizeof (*msg));
976 }
977
978 /*ARGSUSED*/
979 static void
980 stmf_ic_reg_port_msg_free(stmf_ic_reg_port_msg_t *m,
981 stmf_ic_msg_construction_method_t cmethod)
982 {
983 scsi_devid_desc_free(m->icrp_port_id);
984
985 kmem_free(m, sizeof (*m));
986 }
987
988
989 /*ARGSUSED*/
990 static void
991 stmf_ic_dereg_port_msg_free(stmf_ic_dereg_port_msg_t *m,
992 stmf_ic_msg_construction_method_t cmethod)
993 {
994 scsi_devid_desc_free(m->icdp_port_id);
995
996 kmem_free(m, sizeof (*m));
997 }
998
999
1000 /*
1001 * Works for both reg_lun_msg and dereg_lun_msg, since the message
1002 * payload is the same.
1003 */
1004 static void
1005 stmf_ic_reg_dereg_lun_msg_free(stmf_ic_reg_dereg_lun_msg_t *m,
1006 stmf_ic_msg_construction_method_t cmethod)
1007 {
1008 if (cmethod == STMF_CONSTRUCTOR) {
1009 kmem_free(m->icrl_lu_provider_name,
1010 strlen(m->icrl_lu_provider_name) + 1);
1011 }
1012
1013 kmem_free(m, sizeof (*m));
1014 }
1015
1016 static void
1017 stmf_ic_scsi_cmd_msg_free(stmf_ic_scsi_cmd_msg_t *m,
1018 stmf_ic_msg_construction_method_t cmethod)
1019 {
1020 scsi_devid_desc_free(m->icsc_ini_devid);
1021 scsi_devid_desc_free(m->icsc_tgt_devid);
1022 stmf_remote_port_free(m->icsc_rport);
1023 if ((cmethod == STMF_CONSTRUCTOR) && m->icsc_task_cdb) {
1024 kmem_free(m->icsc_task_cdb, m->icsc_task_cdb_length);
1025 }
1026
1027 kmem_free(m, sizeof (*m));
1028
1029 }
1030
1031 /*ARGSUSED*/
1032 static void
1033 stmf_ic_scsi_data_msg_free(stmf_ic_scsi_data_msg_t *m,
1034 stmf_ic_msg_construction_method_t cmethod)
1035 {
1036 kmem_free(m, sizeof (*m));
1037 }
1038
1039 /*ARGSUSED*/
1040 static void
1041 stmf_ic_scsi_data_xfer_done_msg_free(stmf_ic_scsi_data_xfer_done_msg_t *m,
1042 stmf_ic_msg_construction_method_t cmethod)
1043 {
1044 kmem_free(m, sizeof (*m));
1045 }
1046
1047 /*ARGSUSED*/
1048 static void
1049 stmf_ic_scsi_status_msg_free(stmf_ic_scsi_status_msg_t *m,
1050 stmf_ic_msg_construction_method_t cmethod)
1051 {
1052 kmem_free(m, sizeof (*m));
1053 }
1054
1055 /*ARGSUSED*/
1056 static void
1057 stmf_ic_r2t_msg_free(stmf_ic_r2t_msg_t *m,
1058 stmf_ic_msg_construction_method_t cmethod)
1059 {
1060 kmem_free(m, sizeof (*m));
1061 }
1062
1063 /*ARGSUSED*/
1064 static void
1065 stmf_ic_status_msg_free(stmf_ic_status_msg_t *m,
1066 stmf_ic_msg_construction_method_t cmethod)
1067 {
1068 kmem_free(m, sizeof (*m));
1069 }
1070
1071 /*
1072 * Works for both session_create and session_destroy msgs, since the message
1073 * payload is the same.
1074 */
1075 /*ARGSUSED*/
1076 static void
1077 stmf_ic_session_create_destroy_msg_free(stmf_ic_session_create_destroy_msg_t *m,
1078 stmf_ic_msg_construction_method_t cmethod)
1079 {
1080 scsi_devid_desc_free(m->icscd_ini_devid);
1081 scsi_devid_desc_free(m->icscd_tgt_devid);
1082 stmf_remote_port_free(m->icscd_rport);
1083
1084 kmem_free(m, sizeof (*m));
1085 }
1086
1087 /*ARGSUSED*/
1088 static void
1089 stmf_ic_echo_request_reply_msg_free(stmf_ic_echo_request_reply_msg_t *m,
1090 stmf_ic_msg_construction_method_t cmethod)
1091 {
1092 kmem_free(m, sizeof (*m));
1093 }
1094
1095
1096 /*
1097 * Marshaling routines.
1098 */
1099
1100 static nvlist_t *
1101 stmf_ic_msg_marshal(stmf_ic_msg_t *msg)
1102 {
1103 nvlist_t *nvl = NULL;
1104 int rc = 0;
1105
1106 rc = nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP);
1107 if (rc)
1108 goto done;
1109
1110 NVLIST_ADD_FIELD(uint8, msg, icm_msg_type);
1111 NVLIST_ADD_FIELD(uint64, msg, icm_msgid);
1112
1113 switch (msg->icm_msg_type) {
1114 case STMF_ICM_REGISTER_PROXY_PORT:
1115 rc = stmf_ic_reg_port_msg_marshal(nvl, msg->icm_msg);
1116 break;
1117
1118
1119 case STMF_ICM_DEREGISTER_PROXY_PORT:
1120 rc = stmf_ic_dereg_port_msg_marshal(nvl, msg->icm_msg);
1121 break;
1122
1123 case STMF_ICM_LUN_ACTIVE:
1124 case STMF_ICM_REGISTER_LUN:
1125 case STMF_ICM_DEREGISTER_LUN:
1126 rc = stmf_ic_reg_dereg_lun_msg_marshal(nvl, msg->icm_msg);
1127 break;
1128
1129 case STMF_ICM_SCSI_CMD:
1130 rc = stmf_ic_scsi_cmd_msg_marshal(nvl, msg->icm_msg);
1131 break;
1132
1133 case STMF_ICM_SCSI_DATA:
1134 rc = stmf_ic_scsi_data_msg_marshal(nvl, msg->icm_msg);
1135 break;
1136
1137 case STMF_ICM_SCSI_DATA_XFER_DONE:
1138 rc = stmf_ic_scsi_data_xfer_done_msg_marshal(nvl, msg->icm_msg);
1139 break;
1140
1141 case STMF_ICM_SCSI_STATUS:
1142 rc = stmf_ic_scsi_status_msg_marshal(nvl, msg->icm_msg);
1143 break;
1144
1145 case STMF_ICM_R2T:
1146 rc = stmf_ic_r2t_msg_marshal(nvl, msg->icm_msg);
1147 break;
1148
1149 case STMF_ICM_STATUS:
1150 rc = stmf_ic_status_msg_marshal(nvl, msg->icm_msg);
1151 break;
1152
1153 case STMF_ICM_SESSION_CREATE:
1154 case STMF_ICM_SESSION_DESTROY:
1155 rc = stmf_ic_session_create_destroy_msg_marshal(nvl,
1156 msg->icm_msg);
1157 break;
1158
1159 case STMF_ICM_ECHO_REQUEST:
1160 case STMF_ICM_ECHO_REPLY:
1161 rc = stmf_ic_echo_request_reply_msg_marshal(nvl,
1162 msg->icm_msg);
1163 break;
1164
1165 case STMF_ICM_MAX_MSG_TYPE:
1166 ASSERT(0);
1167 break;
1168
1169 default:
1170 ASSERT(0);
1171 }
1172
1173 done:
1174 if (!rc)
1175 return (nvl);
1176
1177 nvlist_free(nvl);
1178
1179 return (NULL);
1180 }
1181
1182
1183 static int
1184 stmf_ic_reg_port_msg_marshal(nvlist_t *nvl, void *msg)
1185 {
1186 stmf_ic_reg_port_msg_t *m = (stmf_ic_reg_port_msg_t *)msg;
1187 int rc = 0;
1188
1189 NVLIST_ADD_DEVID(m, icrp_port_id);
1190 NVLIST_ADD_FIELD(uint16, m, icrp_relative_port_id);
1191
1192 NVLIST_ADD_FIELD(uint16, m, icrp_cb_arg_len);
1193 /* only add the callback arg if necessary */
1194 if (m->icrp_cb_arg_len) {
1195 NVLIST_ADD_ARRAY_LEN(uint8, m, icrp_cb_arg, m->icrp_cb_arg_len);
1196 }
1197
1198 done:
1199 return (rc);
1200 }
1201
1202 static int
1203 stmf_ic_dereg_port_msg_marshal(nvlist_t *nvl, void *msg)
1204 {
1205 stmf_ic_dereg_port_msg_t *m = (stmf_ic_dereg_port_msg_t *)msg;
1206 int rc = 0;
1207
1208 NVLIST_ADD_DEVID(m, icdp_port_id);
1209 NVLIST_ADD_FIELD(uint16, m, icdp_cb_arg_len);
1210
1211 /* only add the callback arg if necessary */
1212 if (m->icdp_cb_arg_len) {
1213 NVLIST_ADD_ARRAY_LEN(uint8, m, icdp_cb_arg, m->icdp_cb_arg_len);
1214 }
1215
1216 done:
1217 return (rc);
1218 }
1219
1220 /*
1221 * Handles STMF_ICM_LUN_ACTIVE, STMF_ICM_REGISTER_LUN and
1222 * STMF_ICM_DEREGISTER_LUN;
1223 * msg payload is the same for all.
1224 */
1225 static int
1226 stmf_ic_reg_dereg_lun_msg_marshal(nvlist_t *nvl, void *msg)
1227 {
1228 stmf_ic_reg_dereg_lun_msg_t *m = (stmf_ic_reg_dereg_lun_msg_t *)msg;
1229 int rc = 0;
1230
1231 NVLIST_ADD_ARRAY(uint8, m, icrl_lun_id);
1232 NVLIST_ADD_FIELD(string, m, icrl_lu_provider_name);
1233 NVLIST_ADD_FIELD(uint16, m, icrl_cb_arg_len);
1234
1235 /* only add the callback arg if necessary */
1236 if (m->icrl_cb_arg_len) {
1237 NVLIST_ADD_ARRAY_LEN(uint8, m, icrl_cb_arg, m->icrl_cb_arg_len);
1238 }
1239
1240 done:
1241 return (rc);
1242 }
1243
1244 static int
1245 stmf_ic_scsi_cmd_msg_marshal(nvlist_t *nvl, void *msg)
1246 {
1247 stmf_ic_scsi_cmd_msg_t *m = (stmf_ic_scsi_cmd_msg_t *)msg;
1248 int rc = 0;
1249
1250 NVLIST_ADD_FIELD(uint64, m, icsc_task_msgid);
1251 NVLIST_ADD_DEVID(m, icsc_ini_devid);
1252 NVLIST_ADD_DEVID(m, icsc_tgt_devid);
1253 NVLIST_ADD_RPORT(m, icsc_rport);
1254 NVLIST_ADD_ARRAY(uint8, m, icsc_lun_id);
1255 NVLIST_ADD_FIELD(uint64, m, icsc_session_id);
1256 NVLIST_ADD_ARRAY_LEN(uint8, m, icsc_task_lun_no, 8);
1257 NVLIST_ADD_FIELD(uint32, m, icsc_task_expected_xfer_length);
1258 NVLIST_ADD_FIELD(uint16, m, icsc_task_cdb_length);
1259 /*
1260 * icsc_task_cdb_length may be zero in the case of a task
1261 * management function.
1262 */
1263 NVLIST_ADD_ARRAY_LEN(uint8, m, icsc_task_cdb, m->icsc_task_cdb_length);
1264 NVLIST_ADD_FIELD(uint8, m, icsc_task_flags);
1265 NVLIST_ADD_FIELD(uint8, m, icsc_task_priority);
1266 NVLIST_ADD_FIELD(uint8, m, icsc_task_mgmt_function);
1267
1268 NVLIST_ADD_FIELD(uint32, m, icsc_immed_data_len);
1269 /* only add immediate data if necessary */
1270 if (m->icsc_immed_data_len) {
1271 NVLIST_ADD_ARRAY_LEN(uint8, m, icsc_immed_data,
1272 m->icsc_immed_data_len);
1273 }
1274
1275 done:
1276 return (rc);
1277 }
1278
1279 static int
1280 stmf_ic_scsi_data_msg_marshal(nvlist_t *nvl, void *msg)
1281 {
1282 stmf_ic_scsi_data_msg_t *m = (stmf_ic_scsi_data_msg_t *)msg;
1283 int rc = 0;
1284
1285 NVLIST_ADD_FIELD(uint64, m, icsd_task_msgid);
1286 NVLIST_ADD_FIELD(uint64, m, icsd_session_id);
1287 NVLIST_ADD_ARRAY(uint8, m, icsd_lun_id);
1288 NVLIST_ADD_FIELD(uint64, m, icsd_data_len);
1289 NVLIST_ADD_ARRAY_LEN(uint8, m, icsd_data, m->icsd_data_len);
1290
1291 done:
1292 return (rc);
1293 }
1294
1295 static int
1296 stmf_ic_scsi_data_xfer_done_msg_marshal(nvlist_t *nvl, void *msg)
1297 {
1298 stmf_ic_scsi_data_xfer_done_msg_t *m =
1299 (stmf_ic_scsi_data_xfer_done_msg_t *)msg;
1300 int rc = 0;
1301
1302 NVLIST_ADD_FIELD(uint64, m, icsx_task_msgid);
1303 NVLIST_ADD_FIELD(uint64, m, icsx_session_id);
1304 NVLIST_ADD_FIELD(uint64, m, icsx_status);
1305
1306 done:
1307 return (rc);
1308 }
1309
1310 static int
1311 stmf_ic_scsi_status_msg_marshal(nvlist_t *nvl, void *msg)
1312 {
1313 stmf_ic_scsi_status_msg_t *m = (stmf_ic_scsi_status_msg_t *)msg;
1314 int rc = 0;
1315
1316 NVLIST_ADD_FIELD(uint64, m, icss_task_msgid);
1317 NVLIST_ADD_FIELD(uint64, m, icss_session_id);
1318 NVLIST_ADD_ARRAY(uint8, m, icss_lun_id);
1319 NVLIST_ADD_FIELD(uint8, m, icss_response);
1320 NVLIST_ADD_FIELD(uint8, m, icss_status);
1321 NVLIST_ADD_FIELD(uint8, m, icss_flags);
1322 NVLIST_ADD_FIELD(uint32, m, icss_resid);
1323
1324 NVLIST_ADD_FIELD(uint8, m, icss_sense_len);
1325
1326 if (m->icss_sense_len)
1327 NVLIST_ADD_ARRAY_LEN(uint8, m, icss_sense, m->icss_sense_len);
1328
1329 done:
1330 return (rc);
1331 }
1332
1333 static int
1334 stmf_ic_r2t_msg_marshal(nvlist_t *nvl, void *msg)
1335 {
1336 stmf_ic_r2t_msg_t *m = (stmf_ic_r2t_msg_t *)msg;
1337 int rc = 0;
1338
1339 NVLIST_ADD_FIELD(uint64, m, icrt_task_msgid);
1340 NVLIST_ADD_FIELD(uint64, m, icrt_session_id);
1341 NVLIST_ADD_FIELD(uint32, m, icrt_offset);
1342 NVLIST_ADD_FIELD(uint32, m, icrt_length);
1343
1344 done:
1345 return (rc);
1346 }
1347
1348 static int
1349 stmf_ic_status_msg_marshal(nvlist_t *nvl, void *msg)
1350 {
1351 stmf_ic_status_msg_t *m = (stmf_ic_status_msg_t *)msg;
1352 int rc = 0;
1353
1354 NVLIST_ADD_FIELD(uint8, m, ics_msg_type);
1355 NVLIST_ADD_FIELD(uint64, m, ics_msgid);
1356 NVLIST_ADD_FIELD(uint8, m, ics_status);
1357
1358 done:
1359 return (rc);
1360 }
1361
1362 static int
1363 stmf_ic_session_create_destroy_msg_marshal(nvlist_t *nvl, void *msg)
1364 {
1365 stmf_ic_session_create_destroy_msg_t *m =
1366 (stmf_ic_session_create_destroy_msg_t *)msg;
1367 int rc = 0;
1368
1369 NVLIST_ADD_DEVID(m, icscd_ini_devid);
1370 NVLIST_ADD_DEVID(m, icscd_tgt_devid);
1371 NVLIST_ADD_RPORT(m, icscd_rport);
1372 NVLIST_ADD_FIELD(uint64, m, icscd_session_id);
1373
1374 done:
1375 return (rc);
1376 }
1377
1378 static int
1379 stmf_ic_echo_request_reply_msg_marshal(nvlist_t *nvl, void *msg)
1380 {
1381 stmf_ic_echo_request_reply_msg_t *m = msg;
1382 int rc = 0;
1383
1384 NVLIST_ADD_FIELD(uint32, m, icerr_datalen);
1385 if (m->icerr_datalen)
1386 NVLIST_ADD_ARRAY_LEN(uint8, m, icerr_data, m->icerr_datalen);
1387
1388 done:
1389 return (rc);
1390 }
1391
1392 /*
1393 * Allocate a new nvlist representing the scsi_devid_desc and add it
1394 * to the nvlist.
1395 */
1396 static int
1397 stmf_ic_scsi_devid_desc_marshal(nvlist_t *parent_nvl,
1398 char *sdid_name,
1399 scsi_devid_desc_t *sdid)
1400 {
1401 int rc = 0;
1402 nvlist_t *nvl = NULL;
1403
1404 rc = nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP);
1405 if (rc)
1406 goto done;
1407
1408 NVLIST_ADD_FIELD(uint8, sdid, protocol_id);
1409 NVLIST_ADD_FIELD(uint8, sdid, code_set);
1410 NVLIST_ADD_FIELD(uint8, sdid, piv);
1411 NVLIST_ADD_FIELD(uint8, sdid, association);
1412 NVLIST_ADD_FIELD(uint8, sdid, ident_type);
1413 NVLIST_ADD_FIELD(uint8, sdid, ident_length);
1414
1415 rc = nvlist_add_uint8_array(nvl, "ident", sdid->ident,
1416 sdid->ident_length);
1417 if (rc)
1418 goto done;
1419
1420 rc = nvlist_add_nvlist(parent_nvl, sdid_name, nvl);
1421 done:
1422 if (nvl) {
1423 nvlist_free(nvl);
1424 }
1425 return (rc);
1426 }
1427
1428 /*
1429 * Allocate a new nvlist representing the stmf_remote_port and add it
1430 * to the nvlist.
1431 */
1432 static int
1433 stmf_ic_remote_port_marshal(nvlist_t *parent_nvl, char *rport_name,
1434 stmf_remote_port_t *rport) {
1435
1436 int rc = 0;
1437 nvlist_t *nvl = NULL;
1438
1439 rc = nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP);
1440 if (rc)
1441 goto done;
1442
1443 NVLIST_ADD_FIELD(uint16, rport, rport_tptid_sz);
1444 rc = nvlist_add_uint8_array(nvl, "rport_tptid",
1445 (uint8_t *)rport->rport_tptid, rport->rport_tptid_sz);
1446 if (rc)
1447 goto done;
1448
1449 rc = nvlist_add_nvlist(parent_nvl, rport_name, nvl);
1450 done:
1451 if (nvl) {
1452 nvlist_free(nvl);
1453 }
1454 return (rc);
1455 }
1456
1457 /*
1458 * Unmarshaling routines.
1459 */
1460
1461 static stmf_ic_msg_t *
1462 stmf_ic_msg_unmarshal(nvlist_t *nvl)
1463 {
1464 stmf_ic_msg_t *m = kmem_zalloc(sizeof (*m), KM_SLEEP);
1465 uint8_t msg_type;
1466 int rc = 0;
1467
1468 /*
1469 * We'd like to do this:
1470 *
1471 * NVLIST_LOOKUP_FIELD(uint8, m, icm_msg_type);
1472 *
1473 * but the fact that msg type is an enum causes type problems.
1474 */
1475 rc = nvlist_lookup_uint8(nvl, "icm_msg_type", &msg_type);
1476 if (rc) {
1477 stmf_ic_nvlookup_warn(__func__, "icm_msg_type");
1478 goto done;
1479 }
1480
1481 m->icm_msg_type = msg_type;
1482 m->icm_nvlist = nvl;
1483
1484 NVLIST_LOOKUP_FIELD(uint64, m, icm_msgid);
1485
1486 switch (m->icm_msg_type) {
1487
1488 case STMF_ICM_REGISTER_PROXY_PORT:
1489 m->icm_msg = stmf_ic_reg_port_msg_unmarshal(nvl);
1490 break;
1491
1492
1493 case STMF_ICM_DEREGISTER_PROXY_PORT:
1494 m->icm_msg = stmf_ic_dereg_port_msg_unmarshal(nvl);
1495 break;
1496
1497 case STMF_ICM_LUN_ACTIVE:
1498 case STMF_ICM_REGISTER_LUN:
1499 case STMF_ICM_DEREGISTER_LUN:
1500 m->icm_msg = stmf_ic_reg_dereg_lun_msg_unmarshal(nvl);
1501 break;
1502
1503 case STMF_ICM_SCSI_CMD:
1504 m->icm_msg = stmf_ic_scsi_cmd_msg_unmarshal(nvl);
1505 break;
1506
1507 case STMF_ICM_SCSI_DATA:
1508 m->icm_msg = stmf_ic_scsi_data_msg_unmarshal(nvl);
1509 break;
1510
1511 case STMF_ICM_SCSI_DATA_XFER_DONE:
1512 m->icm_msg = stmf_ic_scsi_data_xfer_done_msg_unmarshal(nvl);
1513 break;
1514
1515 case STMF_ICM_SCSI_STATUS:
1516 m->icm_msg = stmf_ic_scsi_status_msg_unmarshal(nvl);
1517 break;
1518
1519 case STMF_ICM_R2T:
1520 m->icm_msg = stmf_ic_r2t_msg_unmarshal(nvl);
1521 break;
1522
1523 case STMF_ICM_STATUS:
1524 m->icm_msg = stmf_ic_status_msg_unmarshal(nvl);
1525 break;
1526
1527 case STMF_ICM_SESSION_CREATE:
1528 case STMF_ICM_SESSION_DESTROY:
1529 m->icm_msg = stmf_ic_session_create_destroy_msg_unmarshal(nvl);
1530 break;
1531
1532 case STMF_ICM_ECHO_REQUEST:
1533 case STMF_ICM_ECHO_REPLY:
1534 m->icm_msg = stmf_ic_echo_request_reply_msg_unmarshal(nvl);
1535 break;
1536
1537 case STMF_ICM_MAX_MSG_TYPE:
1538 ASSERT(0);
1539 break;
1540
1541 default:
1542 ASSERT(0);
1543 }
1544
1545 done:
1546
1547 if (!m->icm_msg) {
1548 kmem_free(m, sizeof (*m));
1549 return (NULL);
1550 }
1551
1552 return (m);
1553 }
1554
1555 static void *
1556 stmf_ic_reg_port_msg_unmarshal(nvlist_t *nvl)
1557 {
1558 nvlist_t *nvl_port_id = NULL;
1559 int rc = 0;
1560 stmf_ic_reg_port_msg_t *m = kmem_zalloc(sizeof (*m), KM_SLEEP);
1561
1562 rc = nvlist_lookup_nvlist(nvl, "icrp_port_id", &nvl_port_id);
1563 if (rc) {
1564 stmf_ic_nvlookup_warn(__func__, "icrp_port_id nvl");
1565 rc = ENOMEM; /* XXX */
1566 goto done;
1567 }
1568
1569 m->icrp_port_id = stmf_ic_scsi_devid_desc_unmarshal(nvl_port_id);
1570 if (m->icrp_port_id == NULL) {
1571 stmf_ic_nvlookup_warn(__func__, "icrp_port_id");
1572 rc = ENOMEM; /* XXX */
1573 goto done;
1574 }
1575
1576 NVLIST_LOOKUP_FIELD(uint16, m, icrp_relative_port_id);
1577 NVLIST_LOOKUP_FIELD(uint16, m, icrp_cb_arg_len);
1578
1579 if (m->icrp_cb_arg_len) {
1580 m->icrp_cb_arg = stmf_ic_uint8_array_unmarshal(nvl,
1581 "icrp_cb_arg", m->icrp_cb_arg_len, NULL);
1582 if (m->icrp_cb_arg == NULL) {
1583 stmf_ic_nvlookup_warn(__func__, "icrp_cb_arg");
1584 rc = ENOMEM; /* XXX */
1585 goto done;
1586 }
1587 }
1588
1589 done:
1590 if (!rc)
1591 return (m);
1592
1593 stmf_ic_reg_port_msg_free(m, STMF_UNMARSHAL);
1594
1595 return (NULL);
1596 }
1597
1598 /*
1599 * XXX largely the same as stmf_ic_reg_port_msg_unmarshal()
1600 * Common stuff should be factored out. Type issues may make this
1601 * painful.
1602 */
1603 static void *
1604 stmf_ic_dereg_port_msg_unmarshal(nvlist_t *nvl)
1605 {
1606 nvlist_t *nvl_port_id = NULL;
1607 int rc = 0;
1608 stmf_ic_dereg_port_msg_t *m = kmem_zalloc(sizeof (*m), KM_SLEEP);
1609
1610 rc = nvlist_lookup_nvlist(nvl, "icdp_port_id", &nvl_port_id);
1611 if (rc) {
1612 stmf_ic_nvlookup_warn(__func__, "icdp_port_id nvl");
1613 goto done;
1614 }
1615
1616 m->icdp_port_id = stmf_ic_scsi_devid_desc_unmarshal(nvl_port_id);
1617 if (m->icdp_port_id == NULL) {
1618 stmf_ic_nvlookup_warn(__func__, "icdp_port_id");
1619 rc = ENOMEM; /* XXX */
1620 goto done;
1621 }
1622
1623 NVLIST_LOOKUP_FIELD(uint16, m, icdp_cb_arg_len);
1624
1625 if (m->icdp_cb_arg_len) {
1626 m->icdp_cb_arg = stmf_ic_uint8_array_unmarshal(nvl,
1627 "icdp_cb_arg", m->icdp_cb_arg_len, NULL);
1628 if (m->icdp_cb_arg == NULL) {
1629 stmf_ic_nvlookup_warn(__func__, "icdp_cb_arg");
1630 rc = ENOMEM; /* XXX */
1631 goto done;
1632 }
1633 }
1634
1635 done:
1636 if (!rc)
1637 return (m);
1638
1639 stmf_ic_dereg_port_msg_free(m, STMF_UNMARSHAL);
1640
1641 return (NULL);
1642 }
1643
1644 static void *
1645 stmf_ic_reg_dereg_lun_msg_unmarshal(nvlist_t *nvl)
1646 {
1647 int rc = 0;
1648 stmf_ic_reg_dereg_lun_msg_t *m = kmem_zalloc(sizeof (*m), KM_SLEEP);
1649
1650 if (! stmf_ic_uint8_array_unmarshal(nvl, "icrl_lun_id",
1651 sizeof (m->icrl_lun_id), m->icrl_lun_id)) {
1652 stmf_ic_nvlookup_warn(__func__, "icrl_lun_id");
1653 rc = ENOMEM; /* XXX */
1654 goto done;
1655 }
1656
1657 m->icrl_lu_provider_name = stmf_ic_string_unmarshal(nvl,
1658 "icrl_lu_provider_name");
1659
1660 if (!m->icrl_lu_provider_name) {
1661 stmf_ic_nvlookup_warn(__func__, "icrl_lu_provider_name");
1662 rc = ENOMEM; /* XXX */
1663 goto done;
1664 }
1665
1666 NVLIST_LOOKUP_FIELD(uint16, m, icrl_cb_arg_len);
1667
1668 if (m->icrl_cb_arg_len) {
1669 m->icrl_cb_arg = stmf_ic_uint8_array_unmarshal(nvl,
1670 "icrl_cb_arg", m->icrl_cb_arg_len, NULL);
1671 if (m->icrl_cb_arg == NULL) {
1672 stmf_ic_nvlookup_warn(__func__, "icrl_cb_arg");
1673 rc = ENOMEM; /* XXX */
1674 goto done;
1675 }
1676 }
1677
1678 done:
1679 if (!rc)
1680 return (m);
1681
1682 stmf_ic_reg_dereg_lun_msg_free(m, STMF_UNMARSHAL);
1683
1684 return (NULL);
1685 }
1686
1687 static void *
1688 stmf_ic_scsi_cmd_msg_unmarshal(nvlist_t *nvl)
1689 {
1690 int rc = 0;
1691 stmf_ic_scsi_cmd_msg_t *m = kmem_zalloc(sizeof (*m), KM_SLEEP);
1692
1693 if (nvlist_lookup_pairs(nvl, 0,
1694 NV_PAIR(UINT64, m, icsc_task_msgid),
1695 NV_PAIR(UINT64, m, icsc_session_id),
1696 NV_PAIR(UINT32, m, icsc_task_expected_xfer_length),
1697 NV_PAIR(UINT16, m, icsc_task_cdb_length),
1698 NV_PAIR(UINT8, m, icsc_task_flags),
1699 NV_PAIR(UINT8, m, icsc_task_mgmt_function),
1700 NV_PAIR(UINT32, m, icsc_immed_data_len),
1701 NULL) != 0) {
1702 stmf_ic_nvlookup_warn(__func__, "icsc_task_msgid and friends");
1703 rc = ENOMEM; /* XXX need something better */
1704 goto done;
1705 }
1706
1707 m->icsc_ini_devid = stmf_ic_lookup_scsi_devid_desc_and_unmarshal(
1708 nvl, "icsc_ini_devid");
1709 if (m->icsc_ini_devid == NULL) {
1710 stmf_ic_nvlookup_warn(__func__, "icsc_ini_devid");
1711 rc = ENOMEM;
1712 goto done;
1713 }
1714
1715 m->icsc_tgt_devid = stmf_ic_lookup_scsi_devid_desc_and_unmarshal(
1716 nvl, "icsc_tgt_devid");
1717 if (m->icsc_tgt_devid == NULL) {
1718 stmf_ic_nvlookup_warn(__func__, "icsc_tgt_devid");
1719 rc = ENOMEM;
1720 goto done;
1721 }
1722
1723 m->icsc_rport = stmf_ic_lookup_remote_port_and_unmarshal(
1724 nvl, "icsc_rport");
1725 if (m->icsc_rport == NULL) {
1726 stmf_ic_nvlookup_warn(__func__, "icsc_rport");
1727 rc = ENOMEM;
1728 goto done;
1729 }
1730
1731 /* icsc_lun_id */
1732 if (!stmf_ic_uint8_array_unmarshal(nvl, "icsc_lun_id",
1733 sizeof (m->icsc_lun_id), m->icsc_lun_id)) {
1734 stmf_ic_nvlookup_warn(__func__, "icsc_lun_id");
1735 rc = ENOMEM;
1736 goto done;
1737 }
1738
1739 /* icsc_task_lun_no */
1740 if (!stmf_ic_uint8_array_unmarshal(nvl, "icsc_task_lun_no",
1741 sizeof (m->icsc_task_lun_no), m->icsc_task_lun_no)) {
1742 stmf_ic_nvlookup_warn(__func__, "icsc_task_lun_no");
1743 rc = ENOMEM;
1744 goto done;
1745 }
1746
1747 /* icsc_task_cdb */
1748 if (m->icsc_task_cdb_length) {
1749 m->icsc_task_cdb = stmf_ic_uint8_array_unmarshal(nvl,
1750 "icsc_task_cdb", m->icsc_task_cdb_length, NULL);
1751 if (!m->icsc_task_cdb) {
1752 stmf_ic_nvlookup_warn(__func__, "icsc_task_cdb");
1753 rc = ENOMEM;
1754 goto done;
1755 }
1756 }
1757
1758 /* immediate data, if there is any */
1759 if (m->icsc_immed_data_len) {
1760 m->icsc_immed_data = stmf_ic_uint8_array_unmarshal(nvl,
1761 "icsc_immed_data", m->icsc_immed_data_len, NULL);
1762 if (!m->icsc_immed_data) {
1763 stmf_ic_nvlookup_warn(__func__, "icsc_immed_data");
1764 rc = ENOMEM;
1765 goto done;
1766 }
1767 }
1768
1769 done:
1770 if (!rc)
1771 return (m);
1772
1773 stmf_ic_scsi_cmd_msg_free(m, STMF_UNMARSHAL);
1774
1775 return (NULL);
1776 }
1777
1778 static void *
1779 stmf_ic_scsi_data_msg_unmarshal(nvlist_t *nvl)
1780 {
1781 int rc = 0;
1782 stmf_ic_scsi_data_msg_t *m = kmem_zalloc(sizeof (*m), KM_SLEEP);
1783
1784 if (nvlist_lookup_pairs(nvl, 0,
1785 NV_PAIR(UINT64, m, icsd_task_msgid),
1786 NV_PAIR(UINT64, m, icsd_session_id),
1787 NV_PAIR(UINT64, m, icsd_data_len),
1788 NULL) != 0) {
1789 stmf_ic_nvlookup_warn(__func__, "icsd_task_msgid and friends");
1790 rc = ENOMEM; /* XXX need something better */
1791 goto done;
1792 }
1793
1794 if (!stmf_ic_uint8_array_unmarshal(nvl, "icsd_lun_id",
1795 sizeof (m->icsd_lun_id), m->icsd_lun_id)) {
1796 stmf_ic_nvlookup_warn(__func__, "icsd_lun_id");
1797 rc = ENOMEM;
1798 goto done;
1799 }
1800
1801 m->icsd_data = stmf_ic_uint8_array_unmarshal(nvl, "icsd_data",
1802 m->icsd_data_len, NULL);
1803 if (!m->icsd_data) {
1804 stmf_ic_nvlookup_warn(__func__, "icsd_data");
1805 rc = ENOMEM;
1806 goto done;
1807 }
1808
1809 done:
1810 if (!rc)
1811 return (m);
1812
1813 stmf_ic_scsi_data_msg_free(m, STMF_UNMARSHAL);
1814
1815 return (NULL);
1816 }
1817
1818 static void *
1819 stmf_ic_scsi_data_xfer_done_msg_unmarshal(nvlist_t *nvl)
1820 {
1821 int rc = 0;
1822 stmf_ic_scsi_data_xfer_done_msg_t *m =
1823 kmem_zalloc(sizeof (*m), KM_SLEEP);
1824
1825 if (nvlist_lookup_pairs(nvl, 0,
1826 NV_PAIR(UINT64, m, icsx_task_msgid),
1827 NV_PAIR(UINT64, m, icsx_session_id),
1828 NV_PAIR(UINT64, m, icsx_status),
1829 NULL) != 0) {
1830 stmf_ic_nvlookup_warn(__func__, "icsx_task_msgid and friends");
1831 rc = ENOMEM; /* XXX need something better */
1832 goto done;
1833 }
1834
1835 done:
1836 if (!rc)
1837 return (m);
1838
1839 stmf_ic_scsi_data_xfer_done_msg_free(m, STMF_UNMARSHAL);
1840
1841 return (NULL);
1842 }
1843
1844 static void *
1845 stmf_ic_scsi_status_msg_unmarshal(nvlist_t *nvl)
1846 {
1847 int rc = 0;
1848 stmf_ic_scsi_status_msg_t *m = kmem_zalloc(sizeof (*m), KM_SLEEP);
1849
1850 if (nvlist_lookup_pairs(nvl, 0,
1851 NV_PAIR(UINT64, m, icss_task_msgid),
1852 NV_PAIR(UINT64, m, icss_session_id),
1853 NV_PAIR(UINT8, m, icss_response),
1854 NV_PAIR(UINT8, m, icss_status),
1855 NV_PAIR(UINT8, m, icss_flags),
1856 NV_PAIR(UINT32, m, icss_resid),
1857 NV_PAIR(UINT8, m, icss_sense_len),
1858 NULL) != 0) {
1859 stmf_ic_nvlookup_warn(__func__, "icss_task_msgid and friends");
1860 rc = ENOMEM; /* XXX need something better */
1861 goto done;
1862 }
1863
1864 if (!stmf_ic_uint8_array_unmarshal(nvl, "icss_lun_id",
1865 sizeof (m->icss_lun_id), m->icss_lun_id)) {
1866 stmf_ic_nvlookup_warn(__func__, "icss_lun_id");
1867 rc = ENOMEM;
1868 goto done;
1869 }
1870
1871 if (m->icss_sense_len) {
1872 m->icss_sense = stmf_ic_uint8_array_unmarshal(nvl, "icss_sense",
1873 m->icss_sense_len, NULL);
1874 if (!m->icss_sense) {
1875 stmf_ic_nvlookup_warn(__func__, "icss_sense");
1876 rc = ENOMEM;
1877 goto done;
1878 }
1879 }
1880 done:
1881 if (!rc)
1882 return (m);
1883
1884 stmf_ic_scsi_status_msg_free(m, STMF_UNMARSHAL);
1885
1886 return (NULL);
1887 }
1888
1889 static void *
1890 stmf_ic_r2t_msg_unmarshal(nvlist_t *nvl)
1891 {
1892 int rc = 0;
1893 stmf_ic_r2t_msg_t *m = kmem_zalloc(sizeof (*m), KM_SLEEP);
1894
1895 if (nvlist_lookup_pairs(nvl, 0,
1896 NV_PAIR(UINT64, m, icrt_task_msgid),
1897 NV_PAIR(UINT64, m, icrt_session_id),
1898 NV_PAIR(UINT32, m, icrt_offset),
1899 NV_PAIR(UINT32, m, icrt_length),
1900 NULL) != 0) {
1901 stmf_ic_nvlookup_warn(__func__, "icrt_task_msgid and friends");
1902 rc = ENOMEM; /* XXX need something better */
1903 goto done;
1904 }
1905
1906 done:
1907 if (!rc)
1908 return (m);
1909
1910 stmf_ic_r2t_msg_free(m, STMF_UNMARSHAL);
1911
1912 return (NULL);
1913 }
1914
1915 static void *
1916 stmf_ic_session_create_destroy_msg_unmarshal(nvlist_t *nvl)
1917 {
1918 int rc = 0;
1919 stmf_ic_session_create_destroy_msg_t *m = kmem_zalloc(sizeof (*m),
1920 KM_SLEEP);
1921
1922 if (nvlist_lookup_pairs(nvl, 0,
1923 NV_PAIR(UINT64, m, icscd_session_id),
1924 NULL) != 0) {
1925 stmf_ic_nvlookup_warn(__func__, "icsd_session_id");
1926 rc = ENOMEM; /* XXX need something better */
1927 goto done;
1928 }
1929
1930 m->icscd_ini_devid = stmf_ic_lookup_scsi_devid_desc_and_unmarshal(
1931 nvl, "icscd_ini_devid");
1932 if (m->icscd_ini_devid == NULL) {
1933 stmf_ic_nvlookup_warn(__func__, "icsd_ini_devid");
1934 rc = ENOMEM;
1935 goto done;
1936 }
1937
1938 m->icscd_tgt_devid = stmf_ic_lookup_scsi_devid_desc_and_unmarshal(
1939 nvl, "icscd_tgt_devid");
1940 if (m->icscd_tgt_devid == NULL) {
1941 stmf_ic_nvlookup_warn(__func__, "icsd_tgt_devid");
1942 rc = ENOMEM;
1943 goto done;
1944 }
1945
1946 m->icscd_rport = stmf_ic_lookup_remote_port_and_unmarshal(
1947 nvl, "icscd_rport");
1948 if (m->icscd_rport == NULL) {
1949 stmf_ic_nvlookup_warn(__func__, "icscd_rport");
1950 rc = ENOMEM;
1951 goto done;
1952 }
1953
1954 done:
1955 if (!rc)
1956 return (m);
1957
1958 stmf_ic_session_create_destroy_msg_free(m, STMF_UNMARSHAL);
1959
1960 return (NULL);
1961 }
1962
1963 static void *
1964 stmf_ic_echo_request_reply_msg_unmarshal(nvlist_t *nvl)
1965 {
1966 int rc = 0;
1967 stmf_ic_echo_request_reply_msg_t *m = kmem_zalloc(sizeof (*m),
1968 KM_SLEEP);
1969
1970 if (nvlist_lookup_pairs(nvl, 0,
1971 NV_PAIR(UINT32, m, icerr_datalen),
1972 NULL) != 0) {
1973 stmf_ic_nvlookup_warn(__func__, "icerr_datalen");
1974 rc = ENOMEM; /* XXX need something better */
1975 goto done;
1976 }
1977
1978 /* immediate data, if there is any */
1979 if (m->icerr_datalen) {
1980 m->icerr_data = stmf_ic_uint8_array_unmarshal(nvl,
1981 "icerr_data", m->icerr_datalen, NULL);
1982 if (!m->icerr_data) {
1983 stmf_ic_nvlookup_warn(__func__, "icerr_data");
1984 rc = ENOMEM;
1985 goto done;
1986 }
1987 }
1988
1989 done:
1990 if (!rc)
1991 return (m);
1992
1993 stmf_ic_echo_request_reply_msg_free(m, STMF_UNMARSHAL);
1994
1995 return (NULL);
1996 }
1997
1998 static void *
1999 stmf_ic_status_msg_unmarshal(nvlist_t *nvl)
2000 {
2001 int rc = 0;
2002 stmf_ic_status_msg_t *m = kmem_zalloc(sizeof (*m), KM_SLEEP);
2003
2004 if (nvlist_lookup_pairs(nvl, 0,
2005 NV_PAIR(UINT8, m, ics_msg_type),
2006 NV_PAIR(UINT64, m, ics_msgid),
2007 NV_PAIR(UINT8, m, ics_status),
2008 NULL) != 0) {
2009 stmf_ic_nvlookup_warn(__func__, "ics_msg_type and friends");
2010 rc = ENOMEM; /* XXX need something better */
2011 goto done;
2012 }
2013
2014 done:
2015 if (!rc)
2016 return (m);
2017
2018 kmem_free(m, sizeof (*m));
2019 return (NULL);
2020 }
2021
2022
2023 static scsi_devid_desc_t *
2024 stmf_ic_lookup_scsi_devid_desc_and_unmarshal(nvlist_t *nvl, char *field_name)
2025 {
2026 nvlist_t *nvl_devid = NULL;
2027 scsi_devid_desc_t *did = NULL;
2028 int rc;
2029
2030 rc = nvlist_lookup_nvlist(nvl, field_name, &nvl_devid);
2031 if (rc) {
2032 goto done;
2033 }
2034
2035 did = stmf_ic_scsi_devid_desc_unmarshal(nvl_devid);
2036
2037 done:
2038 return (did);
2039 }
2040
2041
2042 static scsi_devid_desc_t *
2043 stmf_ic_scsi_devid_desc_unmarshal(nvlist_t *nvl)
2044 {
2045 scsi_devid_desc_t *sdid = NULL;
2046 uint8_t ident_length = 0;
2047 size_t sdid_size;
2048 int rc = 0;
2049
2050 /*
2051 * we get the ident_length first, since that's the only
2052 * variable-sized field in the struct.
2053 */
2054 rc = nvlist_lookup_uint8(nvl, "ident_length", &ident_length);
2055 if (rc)
2056 goto done;
2057
2058 sdid_size = sizeof_scsi_devid_desc(ident_length);
2059 sdid = kmem_zalloc(sdid_size, KM_SLEEP);
2060
2061 NVLIST_LOOKUP_BIT_FIELD(uint8, sdid, protocol_id);
2062 NVLIST_LOOKUP_BIT_FIELD(uint8, sdid, code_set);
2063 NVLIST_LOOKUP_BIT_FIELD(uint8, sdid, piv);
2064 NVLIST_LOOKUP_BIT_FIELD(uint8, sdid, association);
2065 NVLIST_LOOKUP_BIT_FIELD(uint8, sdid, ident_type);
2066
2067 sdid->ident_length = ident_length;
2068
2069 if (!stmf_ic_uint8_array_unmarshal(nvl, "ident",
2070 sdid->ident_length, sdid->ident)) {
2071 rc = ENOMEM; /* XXX */
2072 goto done;
2073 }
2074
2075 done:
2076 if (!rc)
2077 return (sdid);
2078
2079 kmem_free(sdid, sdid_size);
2080
2081 return (NULL);
2082 }
2083
2084 static stmf_remote_port_t *
2085 stmf_ic_lookup_remote_port_and_unmarshal(nvlist_t *nvl, char *field_name)
2086 {
2087 nvlist_t *nvl_rport = NULL;
2088
2089 if (nvlist_lookup_nvlist(nvl, field_name, &nvl_rport) != 0)
2090 return (NULL);
2091
2092 return (stmf_ic_remote_port_unmarshal(nvl_rport));
2093 }
2094
2095 static stmf_remote_port_t *
2096 stmf_ic_remote_port_unmarshal(nvlist_t *nvl)
2097 {
2098 stmf_remote_port_t *rport = NULL;
2099 uint16_t rport_tptid_sz = 0;
2100 int rc = 0;
2101
2102 rc = nvlist_lookup_uint16(nvl, "rport_tptid_sz", &rport_tptid_sz);
2103 if (rc || rport_tptid_sz < sizeof (scsi_transport_id_t))
2104 return (NULL);
2105
2106 rport = stmf_remote_port_alloc(rport_tptid_sz);
2107 if (!stmf_ic_uint8_array_unmarshal(nvl, "rport_tptid", rport_tptid_sz,
2108 (uint8_t *)rport->rport_tptid)) {
2109 stmf_remote_port_free(rport);
2110 rport = NULL;
2111 }
2112 return (rport);
2113 }
2114
2115 /*
2116 * Unmarshal a uint8_t array.
2117 *
2118 * Takes a buf argument:
2119 *
2120 * - if non-null, the array contents are copied into the buf,
2121 * and we return a pointer to the buffer.
2122 *
2123 * - if null, we return a pointer to the unmarshaled data, which
2124 * resides in the nvlist.
2125 *
2126 * Returns NULL on failure.
2127 */
2128 static uint8_t *
2129 stmf_ic_uint8_array_unmarshal(
2130 nvlist_t *nvl,
2131 char *field_name,
2132 uint64_t len,
2133 uint8_t *buf) /* non-NULL: copy array into buf */
2134 {
2135 uint8_t *array = NULL;
2136 uint_t actual_len;
2137 int rc = 0;
2138
2139 rc = nvlist_lookup_uint8_array(nvl, field_name, &array, &actual_len);
2140 if (rc) {
2141 return (NULL);
2142 }
2143
2144 if (len != actual_len) {
2145 cmn_err(CE_WARN,
2146 "stmf_ic_uint8_array_unmarshal: wrong len (%d != %d)",
2147 (int)len, actual_len);
2148 return (NULL);
2149 }
2150
2151 if (buf) {
2152 /* preallocated buf, copy in */
2153 bcopy(array, buf, len);
2154 } else {
2155 /* return a pointer to the underlying array in the nvlist */
2156 buf = array;
2157 }
2158
2159 return (buf);
2160 }
2161
2162 /*
2163 * Unmarshal a string.
2164 *
2165 * Returns NULL on failure.
2166 */
2167 static char *
2168 stmf_ic_string_unmarshal(
2169 nvlist_t *nvl,
2170 char *field_name)
2171 {
2172 char *s = NULL;
2173 int rc = 0;
2174
2175 rc = nvlist_lookup_string(nvl, field_name, &s);
2176 if (rc) {
2177 return (NULL);
2178 }
2179
2180 return (s);
2181 }
2182
2183 /*
2184 * Utility routines.
2185 */
2186
2187 static stmf_ic_msg_t *
2188 stmf_ic_alloc_msg_header(
2189 stmf_ic_msg_type_t msg_type,
2190 stmf_ic_msgid_t msgid)
2191 {
2192 stmf_ic_msg_t *icm;
2193
2194 icm = (stmf_ic_msg_t *)kmem_zalloc(sizeof (*icm), KM_SLEEP);
2195 icm->icm_msg_type = msg_type;
2196 icm->icm_msgid = msgid;
2197
2198 return (icm);
2199 }
2200
2201 static size_t
2202 sizeof_scsi_devid_desc(int ident_length)
2203 {
2204 int num_ident_elems;
2205 size_t size;
2206
2207 ASSERT(ident_length > 0);
2208
2209 /*
2210 * Need to account for the fact that there's
2211 * already a single element in scsi_devid_desc_t.
2212 *
2213 * XXX would really like to have a way to determine the
2214 * sizeof (struct scsi_devid_desc.ident[0]), but
2215 * it's not clear that can be done.
2216 * Thus, this code relies on the knowledge of the type of
2217 * that field.
2218 */
2219 num_ident_elems = ident_length - 1;
2220 size = sizeof (scsi_devid_desc_t) +
2221 (num_ident_elems * sizeof (uint8_t));
2222
2223 return (size);
2224 }
2225
2226
2227 /*
2228 * Duplicate the scsi_devid_desc_t.
2229 */
2230 static scsi_devid_desc_t *
2231 scsi_devid_desc_dup(scsi_devid_desc_t *did)
2232 {
2233 scsi_devid_desc_t *dup;
2234 size_t dup_size;
2235
2236 ASSERT(did->ident_length > 0);
2237
2238 dup_size = sizeof_scsi_devid_desc(did->ident_length);
2239 dup = (scsi_devid_desc_t *)kmem_zalloc(dup_size, KM_SLEEP);
2240 bcopy(did, dup, dup_size);
2241 return (dup);
2242 }
2243
2244 /*
2245 * May be called with a null pointer.
2246 */
2247 static void
2248 scsi_devid_desc_free(scsi_devid_desc_t *did)
2249 {
2250 if (!did)
2251 return;
2252
2253 kmem_free(did, sizeof_scsi_devid_desc(did->ident_length));
2254 }
2255
2256 /*
2257 * Duplicate the stmf_remote_port_t.
2258 */
2259 static stmf_remote_port_t *
2260 remote_port_dup(stmf_remote_port_t *rport)
2261 {
2262 stmf_remote_port_t *dup = NULL;
2263 if (rport) {
2264 dup = stmf_remote_port_alloc(rport->rport_tptid_sz);
2265 bcopy(rport->rport_tptid, dup->rport_tptid,
2266 rport->rport_tptid_sz);
2267 }
2268 return (dup);
2269 }
2270
2271 /*
2272 * Helper functions, returns NULL if no memory.
2273 */
2274 static char *
2275 stmf_ic_strdup(char *str)
2276 {
2277 char *copy;
2278
2279 ASSERT(str);
2280
2281 copy = kmem_zalloc(strlen(str) + 1, KM_SLEEP);
2282 (void) strcpy(copy, str);
2283 return (copy);
2284 }
2285
2286 static inline void
2287 stmf_ic_nvlookup_warn(const char *func, char *field)
2288 {
2289 cmn_err(CE_WARN, "%s: nvlist lookup of %s failed", func, field);
2290 }