1 /*- 2 * Copyright (c) 2012 The DragonFly Project. All rights reserved. 3 * 4 * This code is derived from software contributed to The DragonFly Project 5 * by Matthew Dillon <dillon@backplane.com> 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * 3. Neither the name of The DragonFly Project nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific, prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 /* 35 * TODO: txcmd CREATE state is deferred by txmsgq, need to calculate 36 * a streaming response. See subr_diskiocom()'s diskiodone(). 37 */ 38 #include <sys/param.h> 39 #include <sys/types.h> 40 #include <sys/kernel.h> 41 #include <sys/conf.h> 42 #include <sys/systm.h> 43 #include <sys/queue.h> 44 #include <sys/tree.h> 45 #include <sys/malloc.h> 46 #include <sys/mount.h> 47 #include <sys/socket.h> 48 #include <sys/vnode.h> 49 #include <sys/file.h> 50 #include <sys/proc.h> 51 #include <sys/priv.h> 52 #include <sys/thread.h> 53 #include <sys/globaldata.h> 54 #include <sys/limits.h> 55 56 #include <sys/dmsg.h> 57 58 RB_GENERATE(kdmsg_state_tree, kdmsg_state, rbnode, kdmsg_state_cmp); 59 RB_GENERATE(kdmsg_circuit_tree, kdmsg_circuit, rbnode, kdmsg_circuit_cmp); 60 61 static int kdmsg_msg_receive_handling(kdmsg_msg_t *msg); 62 static int kdmsg_circ_msgrx(kdmsg_msg_t *msg); 63 static int kdmsg_state_msgrx(kdmsg_msg_t *msg); 64 static int kdmsg_state_msgtx(kdmsg_msg_t *msg); 65 static void kdmsg_state_cleanuprx(kdmsg_msg_t *msg); 66 static void kdmsg_state_cleanuptx(kdmsg_msg_t *msg); 67 static void kdmsg_state_abort(kdmsg_state_t *state); 68 static void kdmsg_state_free(kdmsg_state_t *state); 69 70 static void kdmsg_iocom_thread_rd(void *arg); 71 static void kdmsg_iocom_thread_wr(void *arg); 72 static int kdmsg_autorxmsg(kdmsg_msg_t *msg); 73 static void kdmsg_autocirc(kdmsg_msg_t *msg); 74 static int kdmsg_autocirc_reply(kdmsg_state_t *state, kdmsg_msg_t *msg); 75 76 static struct lwkt_token kdmsg_token = LWKT_TOKEN_INITIALIZER(kdmsg_token); 77 78 void 79 kdmsg_circ_hold(kdmsg_circuit_t *circ) 80 { 81 atomic_add_int(&circ->refs, 1); 82 } 83 84 void 85 kdmsg_circ_drop(kdmsg_circuit_t *circ) 86 { 87 kdmsg_iocom_t *iocom; 88 89 if (atomic_fetchadd_int(&circ->refs, -1) == 1) { 90 KKASSERT(circ->span_state == NULL && 91 circ->circ_state == NULL && 92 circ->rcirc_state == NULL && 93 circ->recorded == 0); 94 iocom = circ->iocom; 95 circ->iocom = NULL; 96 kfree(circ, iocom->mmsg); 97 } 98 } 99 100 101 /* 102 * Initialize the roll-up communications structure for a network 103 * messaging session. This function does not install the socket. 104 */ 105 void 106 kdmsg_iocom_init(kdmsg_iocom_t *iocom, void *handle, uint32_t flags, 107 struct malloc_type *mmsg, 108 int (*rcvmsg)(kdmsg_msg_t *msg)) 109 { 110 bzero(iocom, sizeof(*iocom)); 111 iocom->handle = handle; 112 iocom->mmsg = mmsg; 113 iocom->rcvmsg = rcvmsg; 114 iocom->flags = flags; 115 lockinit(&iocom->msglk, "h2msg", 0, 0); 116 TAILQ_INIT(&iocom->msgq); 117 RB_INIT(&iocom->circ_tree); 118 RB_INIT(&iocom->staterd_tree); 119 RB_INIT(&iocom->statewr_tree); 120 } 121 122 /* 123 * [Re]connect using the passed file pointer. The caller must ref the 124 * fp for us. We own that ref now. 125 */ 126 void 127 kdmsg_iocom_reconnect(kdmsg_iocom_t *iocom, struct file *fp, 128 const char *subsysname) 129 { 130 /* 131 * Destroy the current connection 132 */ 133 lockmgr(&iocom->msglk, LK_EXCLUSIVE); 134 atomic_set_int(&iocom->msg_ctl, KDMSG_CLUSTERCTL_KILL); 135 while (iocom->msgrd_td || iocom->msgwr_td) { 136 wakeup(&iocom->msg_ctl); 137 lksleep(iocom, &iocom->msglk, 0, "clstrkl", hz); 138 } 139 140 /* 141 * Drop communications descriptor 142 */ 143 if (iocom->msg_fp) { 144 fdrop(iocom->msg_fp); 145 iocom->msg_fp = NULL; 146 } 147 148 /* 149 * Setup new communications descriptor 150 */ 151 iocom->msg_ctl = 0; 152 iocom->msg_fp = fp; 153 iocom->msg_seq = 0; 154 iocom->flags &= ~KDMSG_IOCOMF_EXITNOACC; 155 156 lwkt_create(kdmsg_iocom_thread_rd, iocom, &iocom->msgrd_td, 157 NULL, 0, -1, "%s-msgrd", subsysname); 158 lwkt_create(kdmsg_iocom_thread_wr, iocom, &iocom->msgwr_td, 159 NULL, 0, -1, "%s-msgwr", subsysname); 160 lockmgr(&iocom->msglk, LK_RELEASE); 161 } 162 163 /* 164 * Caller sets up iocom->auto_lnk_conn and iocom->auto_lnk_span, then calls 165 * this function to handle the state machine for LNK_CONN and LNK_SPAN. 166 * 167 * NOTE: Caller typically also sets the IOCOMF_AUTOCONN, IOCOMF_AUTOSPAN, 168 * and IOCOMF_AUTOCIRC in the kdmsg_iocom_init() call. Clients 169 * typically set IOCOMF_AUTOFORGE to automatically forged circuits 170 * for received SPANs. 171 */ 172 static int kdmsg_lnk_conn_reply(kdmsg_state_t *state, kdmsg_msg_t *msg); 173 static int kdmsg_lnk_span_reply(kdmsg_state_t *state, kdmsg_msg_t *msg); 174 175 void 176 kdmsg_iocom_autoinitiate(kdmsg_iocom_t *iocom, 177 void (*auto_callback)(kdmsg_msg_t *msg)) 178 { 179 kdmsg_msg_t *msg; 180 181 iocom->auto_callback = auto_callback; 182 183 msg = kdmsg_msg_alloc(iocom, NULL, 184 DMSG_LNK_CONN | DMSGF_CREATE, 185 kdmsg_lnk_conn_reply, NULL); 186 iocom->auto_lnk_conn.head = msg->any.head; 187 msg->any.lnk_conn = iocom->auto_lnk_conn; 188 iocom->conn_state = msg->state; 189 kdmsg_msg_write(msg); 190 } 191 192 static 193 int 194 kdmsg_lnk_conn_reply(kdmsg_state_t *state, kdmsg_msg_t *msg) 195 { 196 kdmsg_iocom_t *iocom = state->iocom; 197 kdmsg_msg_t *rmsg; 198 199 if (msg->any.head.cmd & DMSGF_CREATE) { 200 rmsg = kdmsg_msg_alloc(iocom, NULL, 201 DMSG_LNK_SPAN | DMSGF_CREATE, 202 kdmsg_lnk_span_reply, NULL); 203 iocom->auto_lnk_span.head = rmsg->any.head; 204 rmsg->any.lnk_span = iocom->auto_lnk_span; 205 kdmsg_msg_write(rmsg); 206 } 207 208 /* 209 * Process shim after the CONN is acknowledged and before the CONN 210 * transaction is deleted. For deletions this gives device drivers 211 * the ability to interlock new operations on the circuit before 212 * it becomes illegal and panics. 213 */ 214 if (iocom->auto_callback) 215 iocom->auto_callback(msg); 216 217 if ((state->txcmd & DMSGF_DELETE) == 0 && 218 (msg->any.head.cmd & DMSGF_DELETE)) { 219 iocom->conn_state = NULL; 220 kdmsg_msg_reply(msg, 0); 221 } 222 223 return (0); 224 } 225 226 static 227 int 228 kdmsg_lnk_span_reply(kdmsg_state_t *state, kdmsg_msg_t *msg) 229 { 230 /* 231 * Be sure to process shim before terminating the SPAN 232 * transaction. Gives device drivers the ability to 233 * interlock new operations on the circuit before it 234 * becomes illegal and panics. 235 */ 236 if (state->iocom->auto_callback) 237 state->iocom->auto_callback(msg); 238 239 if ((state->txcmd & DMSGF_DELETE) == 0 && 240 (msg->any.head.cmd & DMSGF_DELETE)) { 241 kdmsg_msg_reply(msg, 0); 242 } 243 return (0); 244 } 245 246 /* 247 * Disconnect and clean up 248 */ 249 void 250 kdmsg_iocom_uninit(kdmsg_iocom_t *iocom) 251 { 252 kdmsg_state_t *state; 253 254 /* 255 * Ask the cluster controller to go away 256 */ 257 lockmgr(&iocom->msglk, LK_EXCLUSIVE); 258 atomic_set_int(&iocom->msg_ctl, KDMSG_CLUSTERCTL_KILL); 259 260 while (iocom->msgrd_td || iocom->msgwr_td) { 261 wakeup(&iocom->msg_ctl); 262 lksleep(iocom, &iocom->msglk, 0, "clstrkl", hz); 263 } 264 265 /* 266 * Cleanup caches 267 */ 268 if ((state = iocom->freerd_state) != NULL) { 269 iocom->freerd_state = NULL; 270 kdmsg_state_free(state); 271 } 272 273 if ((state = iocom->freewr_state) != NULL) { 274 iocom->freewr_state = NULL; 275 kdmsg_state_free(state); 276 } 277 278 /* 279 * Drop communications descriptor 280 */ 281 if (iocom->msg_fp) { 282 fdrop(iocom->msg_fp); 283 iocom->msg_fp = NULL; 284 } 285 lockmgr(&iocom->msglk, LK_RELEASE); 286 } 287 288 /* 289 * Cluster controller thread. Perform messaging functions. We have one 290 * thread for the reader and one for the writer. The writer handles 291 * shutdown requests (which should break the reader thread). 292 */ 293 static 294 void 295 kdmsg_iocom_thread_rd(void *arg) 296 { 297 kdmsg_iocom_t *iocom = arg; 298 dmsg_hdr_t hdr; 299 kdmsg_msg_t *msg = NULL; 300 size_t hbytes; 301 size_t abytes; 302 int error = 0; 303 304 while ((iocom->msg_ctl & KDMSG_CLUSTERCTL_KILL) == 0) { 305 /* 306 * Retrieve the message from the pipe or socket. 307 */ 308 error = fp_read(iocom->msg_fp, &hdr, sizeof(hdr), 309 NULL, 1, UIO_SYSSPACE); 310 if (error) 311 break; 312 if (hdr.magic != DMSG_HDR_MAGIC) { 313 kprintf("kdmsg: bad magic: %04x\n", hdr.magic); 314 error = EINVAL; 315 break; 316 } 317 hbytes = (hdr.cmd & DMSGF_SIZE) * DMSG_ALIGN; 318 if (hbytes < sizeof(hdr) || hbytes > DMSG_AUX_MAX) { 319 kprintf("kdmsg: bad header size %zd\n", hbytes); 320 error = EINVAL; 321 break; 322 } 323 /* XXX messy: mask cmd to avoid allocating state */ 324 msg = kdmsg_msg_alloc(iocom, NULL, 325 hdr.cmd & DMSGF_BASECMDMASK, 326 NULL, NULL); 327 msg->any.head = hdr; 328 msg->hdr_size = hbytes; 329 if (hbytes > sizeof(hdr)) { 330 error = fp_read(iocom->msg_fp, &msg->any.head + 1, 331 hbytes - sizeof(hdr), 332 NULL, 1, UIO_SYSSPACE); 333 if (error) { 334 kprintf("kdmsg: short msg received\n"); 335 error = EINVAL; 336 break; 337 } 338 } 339 msg->aux_size = hdr.aux_bytes; 340 if (msg->aux_size > DMSG_AUX_MAX) { 341 kprintf("kdmsg: illegal msg payload size %zd\n", 342 msg->aux_size); 343 error = EINVAL; 344 break; 345 } 346 if (msg->aux_size) { 347 abytes = DMSG_DOALIGN(msg->aux_size); 348 msg->aux_data = kmalloc(abytes, iocom->mmsg, M_WAITOK); 349 msg->flags |= KDMSG_FLAG_AUXALLOC; 350 error = fp_read(iocom->msg_fp, msg->aux_data, 351 abytes, NULL, 1, UIO_SYSSPACE); 352 if (error) { 353 kprintf("kdmsg: short msg payload received\n"); 354 break; 355 } 356 } 357 358 (void)kdmsg_circ_msgrx(msg); 359 error = kdmsg_msg_receive_handling(msg); 360 msg = NULL; 361 } 362 363 if (error) 364 kprintf("kdmsg: read failed error %d\n", error); 365 366 lockmgr(&iocom->msglk, LK_EXCLUSIVE); 367 if (msg) 368 kdmsg_msg_free(msg); 369 370 /* 371 * Shutdown the socket before waiting for the transmit side. 372 * 373 * If we are dying due to e.g. a socket disconnect verses being 374 * killed explicity we have to set KILL in order to kick the tx 375 * side when it might not have any other work to do. KILL might 376 * already be set if we are in an unmount or reconnect. 377 */ 378 fp_shutdown(iocom->msg_fp, SHUT_RDWR); 379 380 atomic_set_int(&iocom->msg_ctl, KDMSG_CLUSTERCTL_KILL); 381 wakeup(&iocom->msg_ctl); 382 383 /* 384 * Wait for the transmit side to drain remaining messages 385 * before cleaning up the rx state. The transmit side will 386 * set KILLTX and wait for the rx side to completely finish 387 * (set msgrd_td to NULL) before cleaning up any remaining 388 * tx states. 389 */ 390 lockmgr(&iocom->msglk, LK_RELEASE); 391 atomic_set_int(&iocom->msg_ctl, KDMSG_CLUSTERCTL_KILLRX); 392 wakeup(&iocom->msg_ctl); 393 while ((iocom->msg_ctl & KDMSG_CLUSTERCTL_KILLTX) == 0) { 394 wakeup(&iocom->msg_ctl); 395 tsleep(iocom, 0, "clstrkw", hz); 396 } 397 398 iocom->msgrd_td = NULL; 399 400 /* 401 * iocom can be ripped out from under us at this point but 402 * wakeup() is safe. 403 */ 404 wakeup(iocom); 405 lwkt_exit(); 406 } 407 408 static 409 void 410 kdmsg_iocom_thread_wr(void *arg) 411 { 412 kdmsg_iocom_t *iocom = arg; 413 kdmsg_msg_t *msg; 414 kdmsg_state_t *state; 415 ssize_t res; 416 size_t abytes; 417 int error = 0; 418 int retries = 20; 419 420 /* 421 * Transmit loop 422 */ 423 msg = NULL; 424 lockmgr(&iocom->msglk, LK_EXCLUSIVE); 425 426 while ((iocom->msg_ctl & KDMSG_CLUSTERCTL_KILL) == 0 && error == 0) { 427 /* 428 * Sleep if no messages pending. Interlock with flag while 429 * holding msglk. 430 */ 431 if (TAILQ_EMPTY(&iocom->msgq)) { 432 atomic_set_int(&iocom->msg_ctl, 433 KDMSG_CLUSTERCTL_SLEEPING); 434 lksleep(&iocom->msg_ctl, &iocom->msglk, 0, "msgwr", hz); 435 atomic_clear_int(&iocom->msg_ctl, 436 KDMSG_CLUSTERCTL_SLEEPING); 437 } 438 439 while ((msg = TAILQ_FIRST(&iocom->msgq)) != NULL) { 440 /* 441 * Remove msg from the transmit queue and do 442 * persist and half-closed state handling. 443 */ 444 TAILQ_REMOVE(&iocom->msgq, msg, qentry); 445 lockmgr(&iocom->msglk, LK_RELEASE); 446 447 error = kdmsg_state_msgtx(msg); 448 if (error == EALREADY) { 449 error = 0; 450 kdmsg_msg_free(msg); 451 lockmgr(&iocom->msglk, LK_EXCLUSIVE); 452 continue; 453 } 454 if (error) { 455 kdmsg_msg_free(msg); 456 lockmgr(&iocom->msglk, LK_EXCLUSIVE); 457 break; 458 } 459 460 /* 461 * Dump the message to the pipe or socket. 462 * 463 * We have to clean up the message as if the transmit 464 * succeeded even if it failed. 465 */ 466 error = fp_write(iocom->msg_fp, &msg->any, 467 msg->hdr_size, &res, UIO_SYSSPACE); 468 if (error || res != msg->hdr_size) { 469 if (error == 0) 470 error = EINVAL; 471 kdmsg_state_cleanuptx(msg); 472 lockmgr(&iocom->msglk, LK_EXCLUSIVE); 473 break; 474 } 475 if (msg->aux_size) { 476 abytes = DMSG_DOALIGN(msg->aux_size); 477 error = fp_write(iocom->msg_fp, 478 msg->aux_data, abytes, 479 &res, UIO_SYSSPACE); 480 if (error || res != abytes) { 481 if (error == 0) 482 error = EINVAL; 483 kdmsg_state_cleanuptx(msg); 484 lockmgr(&iocom->msglk, LK_EXCLUSIVE); 485 break; 486 } 487 } 488 kdmsg_state_cleanuptx(msg); 489 lockmgr(&iocom->msglk, LK_EXCLUSIVE); 490 } 491 } 492 493 /* 494 * Cleanup messages pending transmission and release msgq lock. 495 */ 496 if (error) 497 kprintf("kdmsg: write failed error %d\n", error); 498 kprintf("thread_wr: Terminating iocom\n"); 499 500 /* 501 * Shutdown the socket. This will cause the rx thread to get an 502 * EOF and ensure that both threads get to a termination state. 503 */ 504 fp_shutdown(iocom->msg_fp, SHUT_RDWR); 505 506 /* 507 * Set KILLTX (which the rx side waits for), then wait for the RX 508 * side to completely finish before we clean out any remaining 509 * command states. 510 */ 511 lockmgr(&iocom->msglk, LK_RELEASE); 512 atomic_set_int(&iocom->msg_ctl, KDMSG_CLUSTERCTL_KILLTX); 513 wakeup(&iocom->msg_ctl); 514 while (iocom->msgrd_td) { 515 wakeup(&iocom->msg_ctl); 516 tsleep(iocom, 0, "clstrkw", hz); 517 } 518 lockmgr(&iocom->msglk, LK_EXCLUSIVE); 519 520 /* 521 * Simulate received MSGF_DELETE's for any remaining states. 522 * (For remote masters). 523 * 524 * Drain the message queue to handle any device initiated writes 525 * due to state callbacks. 526 */ 527 cleanuprd: 528 kdmsg_drain_msgq(iocom); 529 RB_FOREACH(state, kdmsg_state_tree, &iocom->staterd_tree) { 530 if ((state->rxcmd & DMSGF_DELETE) == 0) { 531 lockmgr(&iocom->msglk, LK_RELEASE); 532 kdmsg_state_abort(state); 533 lockmgr(&iocom->msglk, LK_EXCLUSIVE); 534 goto cleanuprd; 535 } 536 } 537 538 /* 539 * Simulate received MSGF_DELETE's for any remaining states. 540 * (For local masters). 541 */ 542 cleanupwr: 543 kdmsg_drain_msgq(iocom); 544 RB_FOREACH(state, kdmsg_state_tree, &iocom->statewr_tree) { 545 if ((state->rxcmd & DMSGF_DELETE) == 0) { 546 lockmgr(&iocom->msglk, LK_RELEASE); 547 kdmsg_state_abort(state); 548 lockmgr(&iocom->msglk, LK_EXCLUSIVE); 549 goto cleanupwr; 550 } 551 } 552 553 /* 554 * Retry until all work is done 555 */ 556 if (--retries == 0) 557 panic("kdmsg: comm thread shutdown couldn't drain"); 558 if (TAILQ_FIRST(&iocom->msgq) || 559 RB_ROOT(&iocom->staterd_tree) || 560 RB_ROOT(&iocom->statewr_tree)) { 561 goto cleanuprd; 562 } 563 iocom->flags |= KDMSG_IOCOMF_EXITNOACC; 564 565 lockmgr(&iocom->msglk, LK_RELEASE); 566 567 /* 568 * The state trees had better be empty now 569 */ 570 KKASSERT(RB_EMPTY(&iocom->staterd_tree)); 571 KKASSERT(RB_EMPTY(&iocom->statewr_tree)); 572 KKASSERT(iocom->conn_state == NULL); 573 574 if (iocom->exit_func) { 575 /* 576 * iocom is invalid after we call the exit function. 577 */ 578 iocom->msgwr_td = NULL; 579 iocom->exit_func(iocom); 580 } else { 581 /* 582 * iocom can be ripped out from under us once msgwr_td is 583 * set to NULL. The wakeup is safe. 584 */ 585 iocom->msgwr_td = NULL; 586 wakeup(iocom); 587 } 588 lwkt_exit(); 589 } 590 591 /* 592 * This cleans out the pending transmit message queue, adjusting any 593 * persistent states properly in the process. 594 * 595 * Caller must hold pmp->iocom.msglk 596 */ 597 void 598 kdmsg_drain_msgq(kdmsg_iocom_t *iocom) 599 { 600 kdmsg_msg_t *msg; 601 602 /* 603 * Clean out our pending transmit queue, executing the 604 * appropriate state adjustments. If this tries to open 605 * any new outgoing transactions we have to loop up and 606 * clean them out. 607 */ 608 while ((msg = TAILQ_FIRST(&iocom->msgq)) != NULL) { 609 TAILQ_REMOVE(&iocom->msgq, msg, qentry); 610 lockmgr(&iocom->msglk, LK_RELEASE); 611 if (kdmsg_state_msgtx(msg)) 612 kdmsg_msg_free(msg); 613 else 614 kdmsg_state_cleanuptx(msg); 615 lockmgr(&iocom->msglk, LK_EXCLUSIVE); 616 } 617 } 618 619 /* 620 * Do all processing required to handle a freshly received message 621 * after its low level header has been validated. 622 */ 623 static 624 int 625 kdmsg_msg_receive_handling(kdmsg_msg_t *msg) 626 { 627 kdmsg_iocom_t *iocom = msg->iocom; 628 int error; 629 630 /* 631 * State machine tracking, state assignment for msg, 632 * returns error and discard status. Errors are fatal 633 * to the connection except for EALREADY which forces 634 * a discard without execution. 635 */ 636 error = kdmsg_state_msgrx(msg); 637 if (error) { 638 /* 639 * Raw protocol or connection error 640 */ 641 kdmsg_msg_free(msg); 642 if (error == EALREADY) 643 error = 0; 644 } else if (msg->state && msg->state->func) { 645 /* 646 * Message related to state which already has a 647 * handling function installed for it. 648 */ 649 error = msg->state->func(msg->state, msg); 650 kdmsg_state_cleanuprx(msg); 651 } else if (iocom->flags & KDMSG_IOCOMF_AUTOANY) { 652 error = kdmsg_autorxmsg(msg); 653 kdmsg_state_cleanuprx(msg); 654 } else { 655 error = iocom->rcvmsg(msg); 656 kdmsg_state_cleanuprx(msg); 657 } 658 return error; 659 } 660 661 /* 662 * Process circuit tracking (NEEDS WORK) 663 */ 664 static 665 int 666 kdmsg_circ_msgrx(kdmsg_msg_t *msg) 667 { 668 kdmsg_circuit_t dummy; 669 kdmsg_circuit_t *circ; 670 int error = 0; 671 672 if (msg->any.head.circuit) { 673 dummy.msgid = msg->any.head.circuit; 674 lwkt_gettoken(&kdmsg_token); 675 circ = RB_FIND(kdmsg_circuit_tree, &msg->iocom->circ_tree, 676 &dummy); 677 if (circ) { 678 msg->circ = circ; 679 kdmsg_circ_hold(circ); 680 } 681 if (circ == NULL) { 682 kprintf("KDMSG_CIRC_MSGRX CMD %08x: IOCOM %p " 683 "Bad circuit %016jx\n", 684 msg->any.head.cmd, 685 msg->iocom, 686 (intmax_t)msg->any.head.circuit); 687 kprintf("KDMSG_CIRC_MSGRX: Avail circuits: "); 688 RB_FOREACH(circ, kdmsg_circuit_tree, 689 &msg->iocom->circ_tree) { 690 kprintf(" %016jx", (intmax_t)circ->msgid); 691 } 692 kprintf("\n"); 693 error = EINVAL; 694 } 695 lwkt_reltoken(&kdmsg_token); 696 } 697 return (error); 698 } 699 700 /* 701 * Process state tracking for a message after reception, prior to 702 * execution. 703 * 704 * Called with msglk held and the msg dequeued. 705 * 706 * All messages are called with dummy state and return actual state. 707 * (One-off messages often just return the same dummy state). 708 * 709 * May request that caller discard the message by setting *discardp to 1. 710 * The returned state is not used in this case and is allowed to be NULL. 711 * 712 * -- 713 * 714 * These routines handle persistent and command/reply message state via the 715 * CREATE and DELETE flags. The first message in a command or reply sequence 716 * sets CREATE, the last message in a command or reply sequence sets DELETE. 717 * 718 * There can be any number of intermediate messages belonging to the same 719 * sequence sent inbetween the CREATE message and the DELETE message, 720 * which set neither flag. This represents a streaming command or reply. 721 * 722 * Any command message received with CREATE set expects a reply sequence to 723 * be returned. Reply sequences work the same as command sequences except the 724 * REPLY bit is also sent. Both the command side and reply side can 725 * degenerate into a single message with both CREATE and DELETE set. Note 726 * that one side can be streaming and the other side not, or neither, or both. 727 * 728 * The msgid is unique for the initiator. That is, two sides sending a new 729 * message can use the same msgid without colliding. 730 * 731 * -- 732 * 733 * ABORT sequences work by setting the ABORT flag along with normal message 734 * state. However, ABORTs can also be sent on half-closed messages, that is 735 * even if the command or reply side has already sent a DELETE, as long as 736 * the message has not been fully closed it can still send an ABORT+DELETE 737 * to terminate the half-closed message state. 738 * 739 * Since ABORT+DELETEs can race we silently discard ABORT's for message 740 * state which has already been fully closed. REPLY+ABORT+DELETEs can 741 * also race, and in this situation the other side might have already 742 * initiated a new unrelated command with the same message id. Since 743 * the abort has not set the CREATE flag the situation can be detected 744 * and the message will also be discarded. 745 * 746 * Non-blocking requests can be initiated with ABORT+CREATE[+DELETE]. 747 * The ABORT request is essentially integrated into the command instead 748 * of being sent later on. In this situation the command implementation 749 * detects that CREATE and ABORT are both set (vs ABORT alone) and can 750 * special-case non-blocking operation for the command. 751 * 752 * NOTE! Messages with ABORT set without CREATE or DELETE are considered 753 * to be mid-stream aborts for command/reply sequences. ABORTs on 754 * one-way messages are not supported. 755 * 756 * NOTE! If a command sequence does not support aborts the ABORT flag is 757 * simply ignored. 758 * 759 * -- 760 * 761 * One-off messages (no reply expected) are sent with neither CREATE or DELETE 762 * set. One-off messages cannot be aborted and typically aren't processed 763 * by these routines. The REPLY bit can be used to distinguish whether a 764 * one-off message is a command or reply. For example, one-off replies 765 * will typically just contain status updates. 766 */ 767 static 768 int 769 kdmsg_state_msgrx(kdmsg_msg_t *msg) 770 { 771 kdmsg_iocom_t *iocom = msg->iocom; 772 kdmsg_state_t *state; 773 int error; 774 775 /* 776 * Make sure a state structure is ready to go in case we need a new 777 * one. This is the only routine which uses freerd_state so no 778 * races are possible. 779 */ 780 if ((state = iocom->freerd_state) == NULL) { 781 state = kmalloc(sizeof(*state), iocom->mmsg, M_WAITOK | M_ZERO); 782 state->flags = KDMSG_STATE_DYNAMIC; 783 iocom->freerd_state = state; 784 } 785 786 /* 787 * Lock RB tree and locate existing persistent state, if any. 788 * 789 * If received msg is a command state is on staterd_tree. 790 * If received msg is a reply state is on statewr_tree. 791 */ 792 lockmgr(&iocom->msglk, LK_EXCLUSIVE); 793 794 state->msgid = msg->any.head.msgid; 795 state->circ = msg->circ; 796 state->iocom = iocom; 797 if (msg->any.head.cmd & DMSGF_REPLY) 798 state = RB_FIND(kdmsg_state_tree, &iocom->statewr_tree, state); 799 else 800 state = RB_FIND(kdmsg_state_tree, &iocom->staterd_tree, state); 801 msg->state = state; 802 803 /* 804 * Short-cut one-off or mid-stream messages (state may be NULL). 805 */ 806 if ((msg->any.head.cmd & (DMSGF_CREATE | DMSGF_DELETE | 807 DMSGF_ABORT)) == 0) { 808 lockmgr(&iocom->msglk, LK_RELEASE); 809 return(0); 810 } 811 812 /* 813 * Switch on CREATE, DELETE, REPLY, and also handle ABORT from 814 * inside the case statements. 815 */ 816 switch(msg->any.head.cmd & (DMSGF_CREATE|DMSGF_DELETE|DMSGF_REPLY)) { 817 case DMSGF_CREATE: 818 case DMSGF_CREATE | DMSGF_DELETE: 819 /* 820 * New persistant command received. 821 */ 822 if (state) { 823 kprintf("kdmsg_state_msgrx: duplicate transaction\n"); 824 error = EINVAL; 825 break; 826 } 827 state = iocom->freerd_state; 828 iocom->freerd_state = NULL; 829 msg->state = state; 830 state->msg = msg; 831 state->icmd = msg->any.head.cmd & DMSGF_BASECMDMASK; 832 state->rxcmd = msg->any.head.cmd & ~DMSGF_DELETE; 833 state->txcmd = DMSGF_REPLY; 834 state->msgid = msg->any.head.msgid; 835 if ((state->circ = msg->circ) != NULL) 836 kdmsg_circ_hold(state->circ); 837 RB_INSERT(kdmsg_state_tree, &iocom->staterd_tree, state); 838 state->flags |= KDMSG_STATE_INSERTED; 839 error = 0; 840 break; 841 case DMSGF_DELETE: 842 /* 843 * Persistent state is expected but might not exist if an 844 * ABORT+DELETE races the close. 845 */ 846 if (state == NULL) { 847 if (msg->any.head.cmd & DMSGF_ABORT) { 848 error = EALREADY; 849 } else { 850 kprintf("kdmsg_state_msgrx: " 851 "no state for DELETE\n"); 852 error = EINVAL; 853 } 854 break; 855 } 856 857 /* 858 * Handle another ABORT+DELETE case if the msgid has already 859 * been reused. 860 */ 861 if ((state->rxcmd & DMSGF_CREATE) == 0) { 862 if (msg->any.head.cmd & DMSGF_ABORT) { 863 error = EALREADY; 864 } else { 865 kprintf("kdmsg_state_msgrx: " 866 "state reused for DELETE\n"); 867 error = EINVAL; 868 } 869 break; 870 } 871 error = 0; 872 break; 873 default: 874 /* 875 * Check for mid-stream ABORT command received, otherwise 876 * allow. 877 */ 878 if (msg->any.head.cmd & DMSGF_ABORT) { 879 if (state == NULL || 880 (state->rxcmd & DMSGF_CREATE) == 0) { 881 error = EALREADY; 882 break; 883 } 884 } 885 error = 0; 886 break; 887 case DMSGF_REPLY | DMSGF_CREATE: 888 case DMSGF_REPLY | DMSGF_CREATE | DMSGF_DELETE: 889 /* 890 * When receiving a reply with CREATE set the original 891 * persistent state message should already exist. 892 */ 893 if (state == NULL) { 894 kprintf("kdmsg_state_msgrx: no state match for " 895 "REPLY cmd=%08x msgid=%016jx\n", 896 msg->any.head.cmd, 897 (intmax_t)msg->any.head.msgid); 898 error = EINVAL; 899 break; 900 } 901 state->rxcmd = msg->any.head.cmd & ~DMSGF_DELETE; 902 error = 0; 903 break; 904 case DMSGF_REPLY | DMSGF_DELETE: 905 /* 906 * Received REPLY+ABORT+DELETE in case where msgid has 907 * already been fully closed, ignore the message. 908 */ 909 if (state == NULL) { 910 if (msg->any.head.cmd & DMSGF_ABORT) { 911 error = EALREADY; 912 } else { 913 kprintf("kdmsg_state_msgrx: no state match " 914 "for REPLY|DELETE\n"); 915 error = EINVAL; 916 } 917 break; 918 } 919 920 /* 921 * Received REPLY+ABORT+DELETE in case where msgid has 922 * already been reused for an unrelated message, 923 * ignore the message. 924 */ 925 if ((state->rxcmd & DMSGF_CREATE) == 0) { 926 if (msg->any.head.cmd & DMSGF_ABORT) { 927 error = EALREADY; 928 } else { 929 kprintf("kdmsg_state_msgrx: state reused " 930 "for REPLY|DELETE\n"); 931 error = EINVAL; 932 } 933 break; 934 } 935 error = 0; 936 break; 937 case DMSGF_REPLY: 938 /* 939 * Check for mid-stream ABORT reply received to sent command. 940 */ 941 if (msg->any.head.cmd & DMSGF_ABORT) { 942 if (state == NULL || 943 (state->rxcmd & DMSGF_CREATE) == 0) { 944 error = EALREADY; 945 break; 946 } 947 } 948 error = 0; 949 break; 950 } 951 lockmgr(&iocom->msglk, LK_RELEASE); 952 return (error); 953 } 954 955 /* 956 * Called instead of iocom->rcvmsg() if any of the AUTO flags are set. 957 * This routine must call iocom->rcvmsg() for anything not automatically 958 * handled. 959 */ 960 static int 961 kdmsg_autorxmsg(kdmsg_msg_t *msg) 962 { 963 kdmsg_iocom_t *iocom = msg->iocom; 964 kdmsg_circuit_t *circ; 965 int error = 0; 966 uint32_t cmd; 967 968 /* 969 * Process a combination of the transaction command and the message 970 * flags. For the purposes of this routine, the message command is 971 * only relevant when it initiates a transaction (where it is 972 * recorded in icmd). 973 */ 974 cmd = (msg->state ? msg->state->icmd : msg->any.head.cmd) & 975 DMSGF_BASECMDMASK; 976 cmd |= msg->any.head.cmd & (DMSGF_CREATE | DMSGF_DELETE | DMSGF_REPLY); 977 978 switch(cmd) { 979 case DMSG_LNK_CONN | DMSGF_CREATE: 980 case DMSG_LNK_CONN | DMSGF_CREATE | DMSGF_DELETE: 981 /* 982 * Received LNK_CONN transaction. Transmit response and 983 * leave transaction open, which allows the other end to 984 * start to the SPAN protocol. 985 * 986 * Handle shim after acknowledging the CONN. 987 */ 988 if ((msg->any.head.cmd & DMSGF_DELETE) == 0) { 989 if (iocom->flags & KDMSG_IOCOMF_AUTOCONN) { 990 kdmsg_msg_result(msg, 0); 991 if (iocom->auto_callback) 992 iocom->auto_callback(msg); 993 } else { 994 error = iocom->rcvmsg(msg); 995 } 996 break; 997 } 998 /* fall through */ 999 case DMSG_LNK_CONN | DMSGF_DELETE: 1000 /* 1001 * This message is usually simulated after a link is lost 1002 * to clean up the transaction. 1003 */ 1004 if (iocom->flags & KDMSG_IOCOMF_AUTOCONN) { 1005 if (iocom->auto_callback) 1006 iocom->auto_callback(msg); 1007 kdmsg_msg_reply(msg, 0); 1008 } else { 1009 error = iocom->rcvmsg(msg); 1010 } 1011 break; 1012 case DMSG_LNK_SPAN | DMSGF_CREATE: 1013 case DMSG_LNK_SPAN | DMSGF_CREATE | DMSGF_DELETE: 1014 /* 1015 * Received LNK_SPAN transaction. We do not have to respond 1016 * but we must leave the transaction open. 1017 * 1018 * If AUTOCIRC is set automatically initiate a virtual circuit 1019 * to the received span. This will attach a kdmsg_circuit 1020 * to the SPAN state. The circuit is lost when the span is 1021 * lost. 1022 * 1023 * Handle shim after acknowledging the SPAN. 1024 */ 1025 if (iocom->flags & KDMSG_IOCOMF_AUTOSPAN) { 1026 if ((msg->any.head.cmd & DMSGF_DELETE) == 0) { 1027 if (iocom->flags & KDMSG_IOCOMF_AUTOFORGE) 1028 kdmsg_autocirc(msg); 1029 if (iocom->auto_callback) 1030 iocom->auto_callback(msg); 1031 break; 1032 } 1033 /* fall through */ 1034 } else { 1035 error = iocom->rcvmsg(msg); 1036 break; 1037 } 1038 /* fall through */ 1039 case DMSG_LNK_SPAN | DMSGF_DELETE: 1040 /* 1041 * Process shims (auto_callback) before cleaning up the 1042 * circuit structure and closing the transactions. Device 1043 * driver should ensure that the circuit is not used after 1044 * the auto_callback() returns. 1045 * 1046 * Handle shim before closing the SPAN transaction. 1047 */ 1048 if (iocom->flags & KDMSG_IOCOMF_AUTOSPAN) { 1049 if (iocom->auto_callback) 1050 iocom->auto_callback(msg); 1051 if (iocom->flags & KDMSG_IOCOMF_AUTOFORGE) 1052 kdmsg_autocirc(msg); 1053 kdmsg_msg_reply(msg, 0); 1054 } else { 1055 error = iocom->rcvmsg(msg); 1056 } 1057 break; 1058 case DMSG_LNK_CIRC | DMSGF_CREATE: 1059 case DMSG_LNK_CIRC | DMSGF_CREATE | DMSGF_DELETE: 1060 /* 1061 * Received LNK_CIRC transaction. We must respond and should 1062 * leave the transaction open, allowing the circuit. The 1063 * remote can start issuing commands to us over the circuit 1064 * even before we respond. 1065 */ 1066 if (iocom->flags & KDMSG_IOCOMF_AUTOCIRC) { 1067 if ((msg->any.head.cmd & DMSGF_DELETE) == 0) { 1068 circ = kmalloc(sizeof(*circ), iocom->mmsg, 1069 M_WAITOK | M_ZERO); 1070 lwkt_gettoken(&kdmsg_token); 1071 msg->state->any.circ = circ; 1072 circ->iocom = iocom; 1073 circ->rcirc_state = msg->state; 1074 kdmsg_circ_hold(circ); /* for rcirc_state */ 1075 circ->weight = 0; 1076 circ->msgid = circ->rcirc_state->msgid; 1077 /* XXX no span link for received circuits */ 1078 kdmsg_circ_hold(circ); /* for circ_state */ 1079 1080 if (RB_INSERT(kdmsg_circuit_tree, 1081 &iocom->circ_tree, circ)) { 1082 panic("duplicate circuitid allocated"); 1083 } 1084 lwkt_reltoken(&kdmsg_token); 1085 kdmsg_msg_result(msg, 0); 1086 1087 /* 1088 * Handle shim after adding the circuit and 1089 * after acknowledging the CIRC. 1090 */ 1091 if (iocom->auto_callback) 1092 iocom->auto_callback(msg); 1093 break; 1094 } 1095 /* fall through */ 1096 } else { 1097 error = iocom->rcvmsg(msg); 1098 break; 1099 } 1100 /* fall through */ 1101 case DMSG_LNK_CIRC | DMSGF_DELETE: 1102 if (iocom->flags & KDMSG_IOCOMF_AUTOCIRC) { 1103 circ = msg->state->any.circ; 1104 if (circ == NULL) 1105 break; 1106 1107 /* 1108 * Handle shim before terminating the circuit. 1109 */ 1110 #if 0 1111 kprintf("KDMSG VC: RECEIVE CIRC DELETE " 1112 "IOCOM %p MSGID %016jx\n", 1113 msg->iocom, circ->msgid); 1114 #endif 1115 if (iocom->auto_callback) 1116 iocom->auto_callback(msg); 1117 1118 KKASSERT(circ->rcirc_state == msg->state); 1119 lwkt_gettoken(&kdmsg_token); 1120 circ->rcirc_state = NULL; 1121 msg->state->any.circ = NULL; 1122 RB_REMOVE(kdmsg_circuit_tree, &iocom->circ_tree, circ); 1123 lwkt_reltoken(&kdmsg_token); 1124 kdmsg_circ_drop(circ); /* for rcirc_state */ 1125 kdmsg_msg_reply(msg, 0); 1126 } else { 1127 error = iocom->rcvmsg(msg); 1128 } 1129 break; 1130 default: 1131 /* 1132 * Anything unhandled goes into rcvmsg. 1133 * 1134 * NOTE: Replies to link-level messages initiated by our side 1135 * are handled by the state callback, they are NOT 1136 * handled here. 1137 */ 1138 error = iocom->rcvmsg(msg); 1139 break; 1140 } 1141 return (error); 1142 } 1143 1144 /* 1145 * Handle automatic forging of virtual circuits based on received SPANs. 1146 * (AUTOFORGE). Note that other code handles tracking received circuit 1147 * transactions (AUTOCIRC). 1148 * 1149 * We can ignore non-transactions here. Use trans->icmd to test the 1150 * transactional command (once past the CREATE the individual message 1151 * commands are not usually the icmd). 1152 * 1153 * XXX locks 1154 */ 1155 static 1156 void 1157 kdmsg_autocirc(kdmsg_msg_t *msg) 1158 { 1159 kdmsg_iocom_t *iocom = msg->iocom; 1160 kdmsg_circuit_t *circ; 1161 kdmsg_msg_t *xmsg; /* CIRC */ 1162 1163 if (msg->state == NULL) 1164 return; 1165 1166 /* 1167 * Gaining the SPAN, automatically forge a circuit to the target. 1168 * 1169 * NOTE!! The shim is not executed until we receive an acknowlegement 1170 * to our forged LNK_CIRC (see kdmsg_autocirc_reply()). 1171 */ 1172 if (msg->state->icmd == DMSG_LNK_SPAN && 1173 (msg->any.head.cmd & DMSGF_CREATE)) { 1174 circ = kmalloc(sizeof(*circ), iocom->mmsg, M_WAITOK | M_ZERO); 1175 lwkt_gettoken(&kdmsg_token); 1176 msg->state->any.circ = circ; 1177 circ->iocom = iocom; 1178 circ->span_state = msg->state; 1179 kdmsg_circ_hold(circ); /* for span_state */ 1180 xmsg = kdmsg_msg_alloc(iocom, NULL, 1181 DMSG_LNK_CIRC | DMSGF_CREATE, 1182 kdmsg_autocirc_reply, circ); 1183 circ->circ_state = xmsg->state; 1184 circ->weight = msg->any.lnk_span.dist; 1185 circ->msgid = circ->circ_state->msgid; 1186 kdmsg_circ_hold(circ); /* for circ_state */ 1187 #if 0 1188 kprintf("KDMSG VC: CREATE SPAN->CIRC IOCOM %p MSGID %016jx\n", 1189 msg->iocom, circ->msgid); 1190 #endif 1191 1192 if (RB_INSERT(kdmsg_circuit_tree, &iocom->circ_tree, circ)) 1193 panic("duplicate circuitid allocated"); 1194 lwkt_reltoken(&kdmsg_token); 1195 1196 xmsg->any.lnk_circ.target = msg->any.head.msgid; 1197 kdmsg_msg_write(xmsg); 1198 } 1199 1200 /* 1201 * Losing the SPAN 1202 * 1203 * NOTE: When losing a SPAN, any circuits using the span should be 1204 * deleted by the remote end first. XXX might not be ordered 1205 * on actual loss of connection. 1206 */ 1207 if (msg->state->icmd == DMSG_LNK_SPAN && 1208 (msg->any.head.cmd & DMSGF_DELETE) && 1209 msg->state->any.circ) { 1210 circ = msg->state->any.circ; 1211 lwkt_gettoken(&kdmsg_token); 1212 circ->span_state = NULL; 1213 msg->state->any.circ = NULL; 1214 RB_REMOVE(kdmsg_circuit_tree, &iocom->circ_tree, circ); 1215 #if 0 1216 kprintf("KDMSG VC: DELETE SPAN->CIRC IOCOM %p MSGID %016jx\n", 1217 msg->iocom, (intmax_t)circ->msgid); 1218 #endif 1219 kdmsg_circ_drop(circ); /* for span_state */ 1220 lwkt_reltoken(&kdmsg_token); 1221 } 1222 } 1223 1224 static 1225 int 1226 kdmsg_autocirc_reply(kdmsg_state_t *state, kdmsg_msg_t *msg) 1227 { 1228 kdmsg_iocom_t *iocom = state->iocom; 1229 kdmsg_circuit_t *circ = state->any.circ; 1230 1231 /* 1232 * Call shim after receiving an acknowlegement to our forged 1233 * circuit and before processing a received termination. 1234 */ 1235 if (iocom->auto_callback) 1236 iocom->auto_callback(msg); 1237 1238 /* 1239 * If the remote is terminating the VC we terminate our side 1240 */ 1241 if ((state->txcmd & DMSGF_DELETE) == 0 && 1242 (msg->any.head.cmd & DMSGF_DELETE)) { 1243 #if 0 1244 kprintf("KDMSG VC: DELETE CIRC FROM REMOTE\n"); 1245 #endif 1246 lwkt_gettoken(&kdmsg_token); 1247 circ->circ_state = NULL; 1248 state->any.circ = NULL; 1249 kdmsg_circ_drop(circ); /* for circ_state */ 1250 lwkt_reltoken(&kdmsg_token); 1251 kdmsg_msg_reply(msg, 0); 1252 } 1253 return (0); 1254 } 1255 1256 /* 1257 * Post-receive-handling message and state cleanup. This routine is called 1258 * after the state function handling/callback to properly dispose of the 1259 * message and update or dispose of the state. 1260 */ 1261 static 1262 void 1263 kdmsg_state_cleanuprx(kdmsg_msg_t *msg) 1264 { 1265 kdmsg_iocom_t *iocom = msg->iocom; 1266 kdmsg_state_t *state; 1267 1268 if ((state = msg->state) == NULL) { 1269 kdmsg_msg_free(msg); 1270 } else if (msg->any.head.cmd & DMSGF_DELETE) { 1271 lockmgr(&iocom->msglk, LK_EXCLUSIVE); 1272 KKASSERT((state->rxcmd & DMSGF_DELETE) == 0); 1273 state->rxcmd |= DMSGF_DELETE; 1274 if (state->txcmd & DMSGF_DELETE) { 1275 KKASSERT(state->flags & KDMSG_STATE_INSERTED); 1276 if (state->rxcmd & DMSGF_REPLY) { 1277 KKASSERT(msg->any.head.cmd & 1278 DMSGF_REPLY); 1279 RB_REMOVE(kdmsg_state_tree, 1280 &iocom->statewr_tree, state); 1281 } else { 1282 KKASSERT((msg->any.head.cmd & 1283 DMSGF_REPLY) == 0); 1284 RB_REMOVE(kdmsg_state_tree, 1285 &iocom->staterd_tree, state); 1286 } 1287 state->flags &= ~KDMSG_STATE_INSERTED; 1288 if (msg != state->msg) 1289 kdmsg_msg_free(msg); 1290 lockmgr(&iocom->msglk, LK_RELEASE); 1291 kdmsg_state_free(state); 1292 } else { 1293 if (msg != state->msg) 1294 kdmsg_msg_free(msg); 1295 lockmgr(&iocom->msglk, LK_RELEASE); 1296 } 1297 } else if (msg != state->msg) { 1298 kdmsg_msg_free(msg); 1299 } 1300 } 1301 1302 /* 1303 * Simulate receiving a message which terminates an active transaction 1304 * state. Our simulated received message must set DELETE and may also 1305 * have to set CREATE. It must also ensure that all fields are set such 1306 * that the receive handling code can find the state (kdmsg_state_msgrx()) 1307 * or an endless loop will ensue. 1308 * 1309 * This is used when the other end of the link or virtual circuit is dead 1310 * so the device driver gets a completed transaction for all pending states. 1311 */ 1312 static 1313 void 1314 kdmsg_state_abort(kdmsg_state_t *state) 1315 { 1316 kdmsg_iocom_t *iocom = state->iocom; 1317 kdmsg_msg_t *msg; 1318 1319 /* 1320 * Prevent recursive aborts which could otherwise occur if the 1321 * simulated message reception runs state->func which then turns 1322 * around and tries to reply to a broken circuit when then calls 1323 * the state abort code again. 1324 */ 1325 if (state->flags & KDMSG_STATE_ABORTING) 1326 return; 1327 state->flags |= KDMSG_STATE_ABORTING; 1328 1329 /* 1330 * Simulatem essage reception 1331 */ 1332 msg = kdmsg_msg_alloc(iocom, state->circ, 1333 DMSG_LNK_ERROR, 1334 NULL, NULL); 1335 if ((state->rxcmd & DMSGF_CREATE) == 0) 1336 msg->any.head.cmd |= DMSGF_CREATE; 1337 msg->any.head.cmd |= DMSGF_DELETE | (state->rxcmd & DMSGF_REPLY); 1338 msg->any.head.error = DMSG_ERR_LOSTLINK; 1339 msg->any.head.msgid = state->msgid; 1340 msg->state = state; 1341 kdmsg_msg_receive_handling(msg); 1342 } 1343 1344 /* 1345 * Process state tracking for a message prior to transmission. 1346 * 1347 * Called with msglk held and the msg dequeued. Returns non-zero if 1348 * the message is bad and should be deleted by the caller. 1349 * 1350 * One-off messages are usually with dummy state and msg->state may be NULL 1351 * in this situation. 1352 * 1353 * New transactions (when CREATE is set) will insert the state. 1354 * 1355 * May request that caller discard the message by setting *discardp to 1. 1356 * A NULL state may be returned in this case. 1357 */ 1358 static 1359 int 1360 kdmsg_state_msgtx(kdmsg_msg_t *msg) 1361 { 1362 kdmsg_iocom_t *iocom = msg->iocom; 1363 kdmsg_state_t *state; 1364 int error; 1365 1366 /* 1367 * Make sure a state structure is ready to go in case we need a new 1368 * one. This is the only routine which uses freewr_state so no 1369 * races are possible. 1370 */ 1371 if ((state = iocom->freewr_state) == NULL) { 1372 state = kmalloc(sizeof(*state), iocom->mmsg, M_WAITOK | M_ZERO); 1373 state->flags = KDMSG_STATE_DYNAMIC; 1374 state->iocom = iocom; 1375 iocom->freewr_state = state; 1376 } 1377 1378 /* 1379 * Lock RB tree. If persistent state is present it will have already 1380 * been assigned to msg. 1381 */ 1382 lockmgr(&iocom->msglk, LK_EXCLUSIVE); 1383 state = msg->state; 1384 1385 /* 1386 * Short-cut one-off or mid-stream messages (state may be NULL). 1387 */ 1388 if ((msg->any.head.cmd & (DMSGF_CREATE | DMSGF_DELETE | 1389 DMSGF_ABORT)) == 0) { 1390 lockmgr(&iocom->msglk, LK_RELEASE); 1391 return(0); 1392 } 1393 1394 1395 /* 1396 * Switch on CREATE, DELETE, REPLY, and also handle ABORT from 1397 * inside the case statements. 1398 */ 1399 switch(msg->any.head.cmd & (DMSGF_CREATE | DMSGF_DELETE | 1400 DMSGF_REPLY)) { 1401 case DMSGF_CREATE: 1402 case DMSGF_CREATE | DMSGF_DELETE: 1403 /* 1404 * Insert the new persistent message state and mark 1405 * half-closed if DELETE is set. Since this is a new 1406 * message it isn't possible to transition into the fully 1407 * closed state here. 1408 * 1409 * XXX state must be assigned and inserted by 1410 * kdmsg_msg_write(). txcmd is assigned by us 1411 * on-transmit. 1412 */ 1413 KKASSERT(state != NULL); 1414 state->icmd = msg->any.head.cmd & DMSGF_BASECMDMASK; 1415 state->txcmd = msg->any.head.cmd & ~DMSGF_DELETE; 1416 state->rxcmd = DMSGF_REPLY; 1417 error = 0; 1418 break; 1419 case DMSGF_DELETE: 1420 /* 1421 * Sent ABORT+DELETE in case where msgid has already 1422 * been fully closed, ignore the message. 1423 */ 1424 if (state == NULL) { 1425 if (msg->any.head.cmd & DMSGF_ABORT) { 1426 error = EALREADY; 1427 } else { 1428 kprintf("kdmsg_state_msgtx: no state match " 1429 "for DELETE cmd=%08x msgid=%016jx\n", 1430 msg->any.head.cmd, 1431 (intmax_t)msg->any.head.msgid); 1432 error = EINVAL; 1433 } 1434 break; 1435 } 1436 1437 /* 1438 * Sent ABORT+DELETE in case where msgid has 1439 * already been reused for an unrelated message, 1440 * ignore the message. 1441 */ 1442 if ((state->txcmd & DMSGF_CREATE) == 0) { 1443 if (msg->any.head.cmd & DMSGF_ABORT) { 1444 error = EALREADY; 1445 } else { 1446 kprintf("kdmsg_state_msgtx: state reused " 1447 "for DELETE\n"); 1448 error = EINVAL; 1449 } 1450 break; 1451 } 1452 error = 0; 1453 break; 1454 default: 1455 /* 1456 * Check for mid-stream ABORT command sent 1457 */ 1458 if (msg->any.head.cmd & DMSGF_ABORT) { 1459 if (state == NULL || 1460 (state->txcmd & DMSGF_CREATE) == 0) { 1461 error = EALREADY; 1462 break; 1463 } 1464 } 1465 error = 0; 1466 break; 1467 case DMSGF_REPLY | DMSGF_CREATE: 1468 case DMSGF_REPLY | DMSGF_CREATE | DMSGF_DELETE: 1469 /* 1470 * When transmitting a reply with CREATE set the original 1471 * persistent state message should already exist. 1472 */ 1473 if (state == NULL) { 1474 kprintf("kdmsg_state_msgtx: no state match " 1475 "for REPLY | CREATE\n"); 1476 error = EINVAL; 1477 break; 1478 } 1479 state->txcmd = msg->any.head.cmd & ~DMSGF_DELETE; 1480 error = 0; 1481 break; 1482 case DMSGF_REPLY | DMSGF_DELETE: 1483 /* 1484 * When transmitting a reply with DELETE set the original 1485 * persistent state message should already exist. 1486 * 1487 * This is very similar to the REPLY|CREATE|* case except 1488 * txcmd is already stored, so we just add the DELETE flag. 1489 * 1490 * Sent REPLY+ABORT+DELETE in case where msgid has 1491 * already been fully closed, ignore the message. 1492 */ 1493 if (state == NULL) { 1494 if (msg->any.head.cmd & DMSGF_ABORT) { 1495 error = EALREADY; 1496 } else { 1497 kprintf("kdmsg_state_msgtx: no state match " 1498 "for REPLY | DELETE\n"); 1499 error = EINVAL; 1500 } 1501 break; 1502 } 1503 1504 /* 1505 * Sent REPLY+ABORT+DELETE in case where msgid has already 1506 * been reused for an unrelated message, ignore the message. 1507 */ 1508 if ((state->txcmd & DMSGF_CREATE) == 0) { 1509 if (msg->any.head.cmd & DMSGF_ABORT) { 1510 error = EALREADY; 1511 } else { 1512 kprintf("kdmsg_state_msgtx: state reused " 1513 "for REPLY | DELETE\n"); 1514 error = EINVAL; 1515 } 1516 break; 1517 } 1518 error = 0; 1519 break; 1520 case DMSGF_REPLY: 1521 /* 1522 * Check for mid-stream ABORT reply sent. 1523 * 1524 * One-off REPLY messages are allowed for e.g. status updates. 1525 */ 1526 if (msg->any.head.cmd & DMSGF_ABORT) { 1527 if (state == NULL || 1528 (state->txcmd & DMSGF_CREATE) == 0) { 1529 error = EALREADY; 1530 break; 1531 } 1532 } 1533 error = 0; 1534 break; 1535 } 1536 lockmgr(&iocom->msglk, LK_RELEASE); 1537 return (error); 1538 } 1539 1540 static 1541 void 1542 kdmsg_state_cleanuptx(kdmsg_msg_t *msg) 1543 { 1544 kdmsg_iocom_t *iocom = msg->iocom; 1545 kdmsg_state_t *state; 1546 1547 if ((state = msg->state) == NULL) { 1548 kdmsg_msg_free(msg); 1549 } else if (msg->any.head.cmd & DMSGF_DELETE) { 1550 lockmgr(&iocom->msglk, LK_EXCLUSIVE); 1551 KKASSERT((state->txcmd & DMSGF_DELETE) == 0); 1552 state->txcmd |= DMSGF_DELETE; 1553 if (state->rxcmd & DMSGF_DELETE) { 1554 KKASSERT(state->flags & KDMSG_STATE_INSERTED); 1555 if (state->txcmd & DMSGF_REPLY) { 1556 KKASSERT(msg->any.head.cmd & 1557 DMSGF_REPLY); 1558 RB_REMOVE(kdmsg_state_tree, 1559 &iocom->staterd_tree, state); 1560 } else { 1561 KKASSERT((msg->any.head.cmd & 1562 DMSGF_REPLY) == 0); 1563 RB_REMOVE(kdmsg_state_tree, 1564 &iocom->statewr_tree, state); 1565 } 1566 state->flags &= ~KDMSG_STATE_INSERTED; 1567 if (msg != state->msg) 1568 kdmsg_msg_free(msg); 1569 lockmgr(&iocom->msglk, LK_RELEASE); 1570 kdmsg_state_free(state); 1571 } else { 1572 if (msg != state->msg) 1573 kdmsg_msg_free(msg); 1574 lockmgr(&iocom->msglk, LK_RELEASE); 1575 } 1576 } else if (msg != state->msg) { 1577 kdmsg_msg_free(msg); 1578 } 1579 } 1580 1581 static 1582 void 1583 kdmsg_state_free(kdmsg_state_t *state) 1584 { 1585 kdmsg_iocom_t *iocom = state->iocom; 1586 kdmsg_msg_t *msg; 1587 1588 KKASSERT((state->flags & KDMSG_STATE_INSERTED) == 0); 1589 msg = state->msg; 1590 state->msg = NULL; 1591 kfree(state, iocom->mmsg); 1592 if (msg) { 1593 msg->state = NULL; 1594 kdmsg_msg_free(msg); 1595 } 1596 } 1597 1598 kdmsg_msg_t * 1599 kdmsg_msg_alloc(kdmsg_iocom_t *iocom, kdmsg_circuit_t *circ, uint32_t cmd, 1600 int (*func)(kdmsg_state_t *, kdmsg_msg_t *), void *data) 1601 { 1602 kdmsg_msg_t *msg; 1603 kdmsg_state_t *state; 1604 size_t hbytes; 1605 1606 KKASSERT(iocom != NULL); 1607 hbytes = (cmd & DMSGF_SIZE) * DMSG_ALIGN; 1608 msg = kmalloc(offsetof(struct kdmsg_msg, any) + hbytes, 1609 iocom->mmsg, M_WAITOK | M_ZERO); 1610 msg->hdr_size = hbytes; 1611 msg->iocom = iocom; 1612 msg->any.head.magic = DMSG_HDR_MAGIC; 1613 msg->any.head.cmd = cmd; 1614 if (circ) { 1615 kdmsg_circ_hold(circ); 1616 msg->circ = circ; 1617 msg->any.head.circuit = circ->msgid; 1618 } 1619 1620 if (cmd & DMSGF_CREATE) { 1621 /* 1622 * New transaction, requires tracking state and a unique 1623 * msgid to be allocated. 1624 */ 1625 KKASSERT(msg->state == NULL); 1626 state = kmalloc(sizeof(*state), iocom->mmsg, M_WAITOK | M_ZERO); 1627 state->flags = KDMSG_STATE_DYNAMIC; 1628 state->func = func; 1629 state->any.any = data; 1630 state->msg = msg; 1631 state->msgid = (uint64_t)(uintptr_t)state; 1632 state->circ = circ; 1633 state->iocom = iocom; 1634 msg->state = state; 1635 if (circ) 1636 kdmsg_circ_hold(circ); 1637 /*msg->any.head.msgid = state->msgid;XXX*/ 1638 1639 lockmgr(&iocom->msglk, LK_EXCLUSIVE); 1640 if (RB_INSERT(kdmsg_state_tree, &iocom->statewr_tree, state)) 1641 panic("duplicate msgid allocated"); 1642 state->flags |= KDMSG_STATE_INSERTED; 1643 msg->any.head.msgid = state->msgid; 1644 lockmgr(&iocom->msglk, LK_RELEASE); 1645 } 1646 return (msg); 1647 } 1648 1649 kdmsg_msg_t * 1650 kdmsg_msg_alloc_state(kdmsg_state_t *state, uint32_t cmd, 1651 int (*func)(kdmsg_state_t *, kdmsg_msg_t *), void *data) 1652 { 1653 kdmsg_iocom_t *iocom = state->iocom; 1654 kdmsg_msg_t *msg; 1655 size_t hbytes; 1656 1657 KKASSERT(iocom != NULL); 1658 hbytes = (cmd & DMSGF_SIZE) * DMSG_ALIGN; 1659 msg = kmalloc(offsetof(struct kdmsg_msg, any) + hbytes, 1660 iocom->mmsg, M_WAITOK | M_ZERO); 1661 msg->hdr_size = hbytes; 1662 msg->iocom = iocom; 1663 msg->any.head.magic = DMSG_HDR_MAGIC; 1664 msg->any.head.cmd = cmd; 1665 msg->state = state; 1666 if (state->circ) { 1667 kdmsg_circ_hold(state->circ); 1668 msg->circ = state->circ; 1669 msg->any.head.circuit = state->circ->msgid; 1670 } 1671 return(msg); 1672 } 1673 1674 void 1675 kdmsg_msg_free(kdmsg_msg_t *msg) 1676 { 1677 kdmsg_iocom_t *iocom = msg->iocom; 1678 1679 if ((msg->flags & KDMSG_FLAG_AUXALLOC) && 1680 msg->aux_data && msg->aux_size) { 1681 kfree(msg->aux_data, iocom->mmsg); 1682 msg->flags &= ~KDMSG_FLAG_AUXALLOC; 1683 } 1684 if (msg->circ) { 1685 kdmsg_circ_drop(msg->circ); 1686 msg->circ = NULL; 1687 } 1688 if (msg->state) { 1689 if (msg->state->msg == msg) 1690 msg->state->msg = NULL; 1691 msg->state = NULL; 1692 } 1693 msg->aux_data = NULL; 1694 msg->aux_size = 0; 1695 msg->iocom = NULL; 1696 kfree(msg, iocom->mmsg); 1697 } 1698 1699 /* 1700 * Circuits are tracked in a red-black tree by their circuit id (msgid). 1701 */ 1702 int 1703 kdmsg_circuit_cmp(kdmsg_circuit_t *circ1, kdmsg_circuit_t *circ2) 1704 { 1705 if (circ1->msgid < circ2->msgid) 1706 return(-1); 1707 if (circ1->msgid > circ2->msgid) 1708 return(1); 1709 return (0); 1710 } 1711 1712 /* 1713 * Indexed messages are stored in a red-black tree indexed by their 1714 * msgid. Only persistent messages are indexed. 1715 */ 1716 int 1717 kdmsg_state_cmp(kdmsg_state_t *state1, kdmsg_state_t *state2) 1718 { 1719 if (state1->iocom < state2->iocom) 1720 return(-1); 1721 if (state1->iocom > state2->iocom) 1722 return(1); 1723 if (state1->circ < state2->circ) 1724 return(-1); 1725 if (state1->circ > state2->circ) 1726 return(1); 1727 if (state1->msgid < state2->msgid) 1728 return(-1); 1729 if (state1->msgid > state2->msgid) 1730 return(1); 1731 return(0); 1732 } 1733 1734 /* 1735 * Write a message. All requisit command flags have been set. 1736 * 1737 * If msg->state is non-NULL the message is written to the existing 1738 * transaction. msgid will be set accordingly. 1739 * 1740 * If msg->state is NULL and CREATE is set new state is allocated and 1741 * (func, data) is installed. A msgid is assigned. 1742 * 1743 * If msg->state is NULL and CREATE is not set the message is assumed 1744 * to be a one-way message. The originator must assign the msgid 1745 * (or leave it 0, which is typical. 1746 * 1747 * This function merely queues the message to the management thread, it 1748 * does not write to the message socket/pipe. 1749 */ 1750 void 1751 kdmsg_msg_write(kdmsg_msg_t *msg) 1752 { 1753 kdmsg_iocom_t *iocom = msg->iocom; 1754 kdmsg_state_t *state; 1755 1756 if (msg->state) { 1757 /* 1758 * Continuance or termination of existing transaction. 1759 * The transaction could have been initiated by either end. 1760 * 1761 * (Function callback and aux data for the receive side can 1762 * be replaced or left alone). 1763 */ 1764 state = msg->state; 1765 msg->any.head.msgid = state->msgid; 1766 lockmgr(&iocom->msglk, LK_EXCLUSIVE); 1767 } else { 1768 /* 1769 * One-off message (always uses msgid 0 to distinguish 1770 * between a possibly lost in-transaction message due to 1771 * competing aborts and a real one-off message?) 1772 */ 1773 state = NULL; 1774 msg->any.head.msgid = 0; 1775 lockmgr(&iocom->msglk, LK_EXCLUSIVE); 1776 } 1777 1778 /* 1779 * With AUTOCIRC and AUTOFORGE it is possible for the circuit to 1780 * get ripped out in the rxthread while some other thread is 1781 * holding a ref on it inbetween allocating and sending a dmsg. 1782 */ 1783 if (msg->circ && msg->circ->rcirc_state == NULL && 1784 (msg->circ->span_state == NULL || msg->circ->circ_state == NULL)) { 1785 kprintf("kdmsg_msg_write: Attempt to write message to " 1786 "terminated circuit: msg %08x\n", msg->any.head.cmd); 1787 lockmgr(&iocom->msglk, LK_RELEASE); 1788 if (kdmsg_state_msgtx(msg)) { 1789 if (state == NULL || msg != state->msg) 1790 kdmsg_msg_free(msg); 1791 } else if ((msg->state->rxcmd & DMSGF_DELETE) == 0) { 1792 /* XXX SMP races simulating a response here */ 1793 kdmsg_state_t *state = msg->state; 1794 kdmsg_state_cleanuptx(msg); 1795 kdmsg_state_abort(state); 1796 } else { 1797 kdmsg_state_cleanuptx(msg); 1798 } 1799 return; 1800 } 1801 1802 /* 1803 * This flag is not set until after the tx thread has drained 1804 * the txmsgq and simulated responses. After that point the 1805 * txthread is dead and can no longer simulate responses. 1806 * 1807 * Device drivers should never try to send a message once this 1808 * flag is set. They should have detected (through the state 1809 * closures) that the link is in trouble. 1810 */ 1811 if (iocom->flags & KDMSG_IOCOMF_EXITNOACC) { 1812 lockmgr(&iocom->msglk, LK_RELEASE); 1813 panic("kdmsg_msg_write: Attempt to write message to " 1814 "terminated iocom\n"); 1815 } 1816 1817 /* 1818 * Finish up the msg fields. Note that msg->aux_size and the 1819 * aux_bytes stored in the message header represent the unaligned 1820 * (actual) bytes of data, but the buffer is sized to an aligned 1821 * size and the CRC is generated over the aligned length. 1822 */ 1823 msg->any.head.salt = /* (random << 8) | */ (iocom->msg_seq & 255); 1824 ++iocom->msg_seq; 1825 1826 if (msg->aux_data && msg->aux_size) { 1827 uint32_t abytes = DMSG_DOALIGN(msg->aux_size); 1828 1829 msg->any.head.aux_bytes = msg->aux_size; 1830 msg->any.head.aux_crc = iscsi_crc32(msg->aux_data, abytes); 1831 } 1832 msg->any.head.hdr_crc = 0; 1833 msg->any.head.hdr_crc = iscsi_crc32(msg->any.buf, msg->hdr_size); 1834 1835 TAILQ_INSERT_TAIL(&iocom->msgq, msg, qentry); 1836 1837 if (iocom->msg_ctl & KDMSG_CLUSTERCTL_SLEEPING) { 1838 atomic_clear_int(&iocom->msg_ctl, 1839 KDMSG_CLUSTERCTL_SLEEPING); 1840 wakeup(&iocom->msg_ctl); 1841 } 1842 1843 lockmgr(&iocom->msglk, LK_RELEASE); 1844 } 1845 1846 /* 1847 * Reply to a message and terminate our side of the transaction. 1848 * 1849 * If msg->state is non-NULL we are replying to a one-way message. 1850 */ 1851 void 1852 kdmsg_msg_reply(kdmsg_msg_t *msg, uint32_t error) 1853 { 1854 kdmsg_state_t *state = msg->state; 1855 kdmsg_msg_t *nmsg; 1856 uint32_t cmd; 1857 1858 /* 1859 * Reply with a simple error code and terminate the transaction. 1860 */ 1861 cmd = DMSG_LNK_ERROR; 1862 1863 /* 1864 * Check if our direction has even been initiated yet, set CREATE. 1865 * 1866 * Check what direction this is (command or reply direction). Note 1867 * that txcmd might not have been initiated yet. 1868 * 1869 * If our direction has already been closed we just return without 1870 * doing anything. 1871 */ 1872 if (state) { 1873 if (state->txcmd & DMSGF_DELETE) 1874 return; 1875 if ((state->txcmd & DMSGF_CREATE) == 0) 1876 cmd |= DMSGF_CREATE; 1877 if (state->txcmd & DMSGF_REPLY) 1878 cmd |= DMSGF_REPLY; 1879 cmd |= DMSGF_DELETE; 1880 } else { 1881 if ((msg->any.head.cmd & DMSGF_REPLY) == 0) 1882 cmd |= DMSGF_REPLY; 1883 } 1884 1885 /* XXX messy mask cmd to avoid allocating state */ 1886 nmsg = kdmsg_msg_alloc_state(state, cmd, NULL, NULL); 1887 nmsg->any.head.error = error; 1888 kdmsg_msg_write(nmsg); 1889 } 1890 1891 /* 1892 * Reply to a message and continue our side of the transaction. 1893 * 1894 * If msg->state is non-NULL we are replying to a one-way message and this 1895 * function degenerates into the same as kdmsg_msg_reply(). 1896 */ 1897 void 1898 kdmsg_msg_result(kdmsg_msg_t *msg, uint32_t error) 1899 { 1900 kdmsg_state_t *state = msg->state; 1901 kdmsg_msg_t *nmsg; 1902 uint32_t cmd; 1903 1904 /* 1905 * Return a simple result code, do NOT terminate the transaction. 1906 */ 1907 cmd = DMSG_LNK_ERROR; 1908 1909 /* 1910 * Check if our direction has even been initiated yet, set CREATE. 1911 * 1912 * Check what direction this is (command or reply direction). Note 1913 * that txcmd might not have been initiated yet. 1914 * 1915 * If our direction has already been closed we just return without 1916 * doing anything. 1917 */ 1918 if (state) { 1919 if (state->txcmd & DMSGF_DELETE) 1920 return; 1921 if ((state->txcmd & DMSGF_CREATE) == 0) 1922 cmd |= DMSGF_CREATE; 1923 if (state->txcmd & DMSGF_REPLY) 1924 cmd |= DMSGF_REPLY; 1925 /* continuing transaction, do not set MSGF_DELETE */ 1926 } else { 1927 if ((msg->any.head.cmd & DMSGF_REPLY) == 0) 1928 cmd |= DMSGF_REPLY; 1929 } 1930 1931 /* XXX messy mask cmd to avoid allocating state */ 1932 nmsg = kdmsg_msg_alloc_state(state, cmd, NULL, NULL); 1933 nmsg->any.head.error = error; 1934 kdmsg_msg_write(nmsg); 1935 } 1936 1937 /* 1938 * Reply to a message and terminate our side of the transaction. 1939 * 1940 * If msg->state is non-NULL we are replying to a one-way message. 1941 */ 1942 void 1943 kdmsg_state_reply(kdmsg_state_t *state, uint32_t error) 1944 { 1945 kdmsg_msg_t *nmsg; 1946 uint32_t cmd; 1947 1948 /* 1949 * Reply with a simple error code and terminate the transaction. 1950 */ 1951 cmd = DMSG_LNK_ERROR; 1952 1953 /* 1954 * Check if our direction has even been initiated yet, set CREATE. 1955 * 1956 * Check what direction this is (command or reply direction). Note 1957 * that txcmd might not have been initiated yet. 1958 * 1959 * If our direction has already been closed we just return without 1960 * doing anything. 1961 */ 1962 KKASSERT(state); 1963 if (state->txcmd & DMSGF_DELETE) 1964 return; 1965 if ((state->txcmd & DMSGF_CREATE) == 0) 1966 cmd |= DMSGF_CREATE; 1967 if (state->txcmd & DMSGF_REPLY) 1968 cmd |= DMSGF_REPLY; 1969 cmd |= DMSGF_DELETE; 1970 1971 /* XXX messy mask cmd to avoid allocating state */ 1972 nmsg = kdmsg_msg_alloc_state(state, cmd, NULL, NULL); 1973 nmsg->any.head.error = error; 1974 kdmsg_msg_write(nmsg); 1975 } 1976 1977 /* 1978 * Reply to a message and continue our side of the transaction. 1979 * 1980 * If msg->state is non-NULL we are replying to a one-way message and this 1981 * function degenerates into the same as kdmsg_msg_reply(). 1982 */ 1983 void 1984 kdmsg_state_result(kdmsg_state_t *state, uint32_t error) 1985 { 1986 kdmsg_msg_t *nmsg; 1987 uint32_t cmd; 1988 1989 /* 1990 * Return a simple result code, do NOT terminate the transaction. 1991 */ 1992 cmd = DMSG_LNK_ERROR; 1993 1994 /* 1995 * Check if our direction has even been initiated yet, set CREATE. 1996 * 1997 * Check what direction this is (command or reply direction). Note 1998 * that txcmd might not have been initiated yet. 1999 * 2000 * If our direction has already been closed we just return without 2001 * doing anything. 2002 */ 2003 KKASSERT(state); 2004 if (state->txcmd & DMSGF_DELETE) 2005 return; 2006 if ((state->txcmd & DMSGF_CREATE) == 0) 2007 cmd |= DMSGF_CREATE; 2008 if (state->txcmd & DMSGF_REPLY) 2009 cmd |= DMSGF_REPLY; 2010 /* continuing transaction, do not set MSGF_DELETE */ 2011 2012 /* XXX messy mask cmd to avoid allocating state */ 2013 nmsg = kdmsg_msg_alloc_state(state, cmd, NULL, NULL); 2014 nmsg->any.head.error = error; 2015 kdmsg_msg_write(nmsg); 2016 } 2017