1 /* 2 * Copyright (c) 2003, 2004 Jeffrey M. Hsu. All rights reserved. 3 * Copyright (c) 2003, 2004 The DragonFly Project. All rights reserved. 4 * 5 * This code is derived from software contributed to The DragonFly Project 6 * by Jeffrey M. Hsu. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 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 the 15 * documentation and/or other materials provided with the distribution. 16 * 3. Neither the name of The DragonFly Project nor the names of its 17 * contributors may be used to endorse or promote products derived 18 * from this software without specific, prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 24 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 27 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 30 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * $DragonFly: src/sys/kern/uipc_msg.c,v 1.20 2007/12/19 11:00:22 sephe Exp $ 34 */ 35 36 #include <sys/param.h> 37 #include <sys/systm.h> 38 #include <sys/msgport.h> 39 #include <sys/protosw.h> 40 #include <sys/socket.h> 41 #include <sys/socketvar.h> 42 #include <sys/socketops.h> 43 #include <sys/thread.h> 44 #include <sys/thread2.h> 45 #include <sys/msgport2.h> 46 #include <net/netmsg2.h> 47 48 #include <net/netisr.h> 49 #include <net/netmsg.h> 50 51 int 52 so_pru_abort(struct socket *so) 53 { 54 int error; 55 struct netmsg_pru_abort msg; 56 lwkt_port_t port; 57 58 port = so->so_proto->pr_mport(so, NULL, NULL, PRU_ABORT); 59 netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0, 60 netmsg_pru_abort); 61 msg.nm_prufn = so->so_proto->pr_usrreqs->pru_abort; 62 msg.nm_so = so; 63 error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0); 64 return (error); 65 } 66 67 int 68 so_pru_accept(struct socket *so, struct sockaddr **nam) 69 { 70 /* Block (memory allocation) in process context. XXX JH */ 71 return ((*so->so_proto->pr_usrreqs->pru_accept)(so, nam)); 72 73 #ifdef notdef 74 int error; 75 struct netmsg_pru_accept msg; 76 lwkt_port_t port; 77 78 port = so->so_proto->pr_mport(so, NULL, NULL, PRU_ACCEPT); 79 netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0, 80 netmsg_pru_accept); 81 msg.nm_prufn = so->so_proto->pr_usrreqs->pru_accept; 82 msg.nm_so = so; 83 msg.nm_nam = nam; 84 error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0); 85 return (error); 86 #endif 87 } 88 89 int 90 so_pru_attach(struct socket *so, int proto, struct pru_attach_info *ai) 91 { 92 int error; 93 struct netmsg_pru_attach msg; 94 lwkt_port_t port; 95 96 port = so->so_proto->pr_mport(NULL, NULL, NULL, PRU_ATTACH); 97 netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0, 98 netmsg_pru_attach); 99 msg.nm_prufn = so->so_proto->pr_usrreqs->pru_attach; 100 msg.nm_so = so; 101 msg.nm_proto = proto; 102 msg.nm_ai = ai; 103 error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0); 104 return (error); 105 } 106 107 int 108 so_pru_bind(struct socket *so, struct sockaddr *nam, struct thread *td) 109 { 110 int error; 111 struct netmsg_pru_bind msg; 112 lwkt_port_t port; 113 114 /* Send mesg to thread for new address. */ 115 port = so->so_proto->pr_mport(NULL, nam, NULL, PRU_BIND); 116 netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0, 117 netmsg_pru_bind); 118 msg.nm_prufn = so->so_proto->pr_usrreqs->pru_bind; 119 msg.nm_so = so; 120 msg.nm_nam = nam; 121 msg.nm_td = td; /* used only for prison_ip() XXX JH */ 122 error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0); 123 return (error); 124 } 125 126 int 127 so_pru_connect(struct socket *so, struct sockaddr *nam, struct thread *td) 128 { 129 int error; 130 struct netmsg_pru_connect msg; 131 lwkt_port_t port; 132 133 port = so->so_proto->pr_mport(so, nam, NULL, PRU_CONNECT); 134 netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0, 135 netmsg_pru_connect); 136 msg.nm_prufn = so->so_proto->pr_usrreqs->pru_connect; 137 msg.nm_so = so; 138 msg.nm_nam = nam; 139 msg.nm_td = td; 140 error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0); 141 return (error); 142 } 143 144 int 145 so_pru_connect2(struct socket *so1, struct socket *so2) 146 { 147 int error; 148 struct netmsg_pru_connect2 msg; 149 lwkt_port_t port; 150 151 port = so1->so_proto->pr_mport(so1, NULL, NULL, PRU_CONNECT2); 152 netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0, 153 netmsg_pru_connect2); 154 msg.nm_prufn = so1->so_proto->pr_usrreqs->pru_connect2; 155 msg.nm_so1 = so1; 156 msg.nm_so2 = so2; 157 error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0); 158 return (error); 159 } 160 161 int 162 so_pru_control(struct socket *so, u_long cmd, caddr_t data, struct ifnet *ifp) 163 { 164 return ((*so->so_proto->pr_usrreqs->pru_control)(so, cmd, data, ifp, 165 curthread)); 166 #ifdef gag /* does copyin and copyout deep inside stack XXX JH */ 167 int error; 168 struct netmsg_pru_control msg; 169 lwkt_port_t port; 170 171 port = so->so_proto->pr_mport(so, NULL, NULL, PRU_CONTROL); 172 netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0, 173 netmsg_pru_control); 174 msg.nm_prufn = so->so_proto->pr_usrreqs->pru_control; 175 msg.nm_so = so; 176 msg.nm_cmd = cmd; 177 msg.nm_data = data; 178 msg.nm_ifp = ifp; 179 msg.nm_td = td; 180 error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0); 181 return (error); 182 #endif 183 } 184 185 int 186 so_pru_detach(struct socket *so) 187 { 188 int error; 189 struct netmsg_pru_detach msg; 190 lwkt_port_t port; 191 192 port = so->so_proto->pr_mport(so, NULL, NULL, PRU_DETACH); 193 netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0, 194 netmsg_pru_detach); 195 msg.nm_prufn = so->so_proto->pr_usrreqs->pru_detach; 196 msg.nm_so = so; 197 error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0); 198 return (error); 199 } 200 201 int 202 so_pru_disconnect(struct socket *so) 203 { 204 int error; 205 struct netmsg_pru_disconnect msg; 206 lwkt_port_t port; 207 208 port = so->so_proto->pr_mport(so, NULL, NULL, PRU_DISCONNECT); 209 netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0, 210 netmsg_pru_disconnect); 211 msg.nm_prufn = so->so_proto->pr_usrreqs->pru_disconnect; 212 msg.nm_so = so; 213 error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0); 214 return (error); 215 } 216 217 int 218 so_pru_listen(struct socket *so, struct thread *td) 219 { 220 int error; 221 struct netmsg_pru_listen msg; 222 lwkt_port_t port; 223 224 port = so->so_proto->pr_mport(so, NULL, NULL, PRU_LISTEN); 225 netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0, 226 netmsg_pru_listen); 227 msg.nm_prufn = so->so_proto->pr_usrreqs->pru_listen; 228 msg.nm_so = so; 229 msg.nm_td = td; /* used only for prison_ip() XXX JH */ 230 error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0); 231 return (error); 232 } 233 234 int 235 so_pru_peeraddr(struct socket *so, struct sockaddr **nam) 236 { 237 int error; 238 struct netmsg_pru_peeraddr msg; 239 lwkt_port_t port; 240 241 port = so->so_proto->pr_mport(so, NULL, NULL, PRU_PEERADDR); 242 netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0, 243 netmsg_pru_peeraddr); 244 msg.nm_prufn = so->so_proto->pr_usrreqs->pru_peeraddr; 245 msg.nm_so = so; 246 msg.nm_nam = nam; 247 error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0); 248 return (error); 249 } 250 251 int 252 so_pru_rcvd(struct socket *so, int flags) 253 { 254 int error; 255 struct netmsg_pru_rcvd msg; 256 lwkt_port_t port; 257 258 port = so->so_proto->pr_mport(so, NULL, NULL, PRU_RCVD); 259 netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0, 260 netmsg_pru_rcvd); 261 msg.nm_prufn = so->so_proto->pr_usrreqs->pru_rcvd; 262 msg.nm_so = so; 263 msg.nm_flags = flags; 264 error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0); 265 return (error); 266 } 267 268 int 269 so_pru_rcvoob(struct socket *so, struct mbuf *m, int flags) 270 { 271 int error; 272 struct netmsg_pru_rcvoob msg; 273 lwkt_port_t port; 274 275 port = so->so_proto->pr_mport(so, NULL, NULL, PRU_RCVOOB); 276 netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0, 277 netmsg_pru_rcvoob); 278 msg.nm_prufn = so->so_proto->pr_usrreqs->pru_rcvoob; 279 msg.nm_so = so; 280 msg.nm_m = m; 281 msg.nm_flags = flags; 282 error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0); 283 return (error); 284 } 285 286 int 287 so_pru_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr, 288 struct mbuf *control, struct thread *td) 289 { 290 int error; 291 struct netmsg_pru_send msg; 292 lwkt_port_t port; 293 294 port = so->so_proto->pr_mport(so, addr, &m, PRU_SEND); 295 if (port == NULL) { 296 KKASSERT(m == NULL); 297 return EINVAL; 298 } 299 300 netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0, 301 netmsg_pru_send); 302 msg.nm_prufn = so->so_proto->pr_usrreqs->pru_send; 303 msg.nm_so = so; 304 msg.nm_flags = flags; 305 msg.nm_m = m; 306 msg.nm_addr = addr; 307 msg.nm_control = control; 308 msg.nm_td = td; 309 error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0); 310 return (error); 311 } 312 313 int 314 so_pru_sense(struct socket *so, struct stat *sb) 315 { 316 int error; 317 struct netmsg_pru_sense msg; 318 lwkt_port_t port; 319 320 port = so->so_proto->pr_mport(so, NULL, NULL, PRU_SENSE); 321 netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0, 322 netmsg_pru_sense); 323 msg.nm_prufn = so->so_proto->pr_usrreqs->pru_sense; 324 msg.nm_so = so; 325 msg.nm_stat = sb; 326 error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0); 327 return (error); 328 } 329 330 int 331 so_pru_shutdown(struct socket *so) 332 { 333 int error; 334 struct netmsg_pru_shutdown msg; 335 lwkt_port_t port; 336 337 port = so->so_proto->pr_mport(so, NULL, NULL, PRU_SHUTDOWN); 338 netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0, 339 netmsg_pru_shutdown); 340 msg.nm_prufn = so->so_proto->pr_usrreqs->pru_shutdown; 341 msg.nm_so = so; 342 error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0); 343 return (error); 344 } 345 346 int 347 so_pru_sockaddr(struct socket *so, struct sockaddr **nam) 348 { 349 int error; 350 struct netmsg_pru_sockaddr msg; 351 lwkt_port_t port; 352 353 port = so->so_proto->pr_mport(so, NULL, NULL, PRU_SOCKADDR); 354 netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0, 355 netmsg_pru_sockaddr); 356 msg.nm_prufn = so->so_proto->pr_usrreqs->pru_sockaddr; 357 msg.nm_so = so; 358 msg.nm_nam = nam; 359 error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0); 360 return (error); 361 } 362 363 int 364 so_pru_sopoll(struct socket *so, int events, struct ucred *cred) 365 { 366 int error; 367 struct netmsg_pru_sopoll msg; 368 lwkt_port_t port; 369 370 port = so->so_proto->pr_mport(so, NULL, NULL, PRU_SOPOLL); 371 netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0, 372 netmsg_pru_sopoll); 373 msg.nm_prufn = so->so_proto->pr_usrreqs->pru_sopoll; 374 msg.nm_so = so; 375 msg.nm_events = events; 376 msg.nm_cred = cred; 377 msg.nm_td = curthread; 378 error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0); 379 return (error); 380 } 381 382 int 383 so_pr_ctloutput(struct socket *so, struct sockopt *sopt) 384 { 385 return ((*so->so_proto->pr_ctloutput)(so, sopt)); 386 #ifdef gag /* does copyin and copyout deep inside stack XXX JH */ 387 struct netmsg_pr_ctloutput msg; 388 lwkt_port_t port; 389 int error; 390 391 port = so->so_proto->pr_mport(so, NULL); 392 netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0, 393 netmsg_pru_ctloutput); 394 msg.nm_prfn = so->so_proto->pr_ctloutput; 395 msg.nm_so = so; 396 msg.nm_sopt = sopt; 397 error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0); 398 return (error); 399 #endif 400 } 401 402 /* 403 * If we convert all the protosw pr_ functions for all the protocols 404 * to take a message directly, this layer can go away. For the moment 405 * our dispatcher ignores the return value, but since we are handling 406 * the replymsg ourselves we return EASYNC by convention. 407 */ 408 void 409 netmsg_pru_abort(netmsg_t msg) 410 { 411 struct netmsg_pru_abort *nm = (void *)msg; 412 413 lwkt_replymsg(&msg->nm_lmsg, nm->nm_prufn(nm->nm_so)); 414 } 415 416 #ifdef notused 417 void 418 netmsg_pru_accept(netmsg_t msg) 419 { 420 struct netmsg_pru_accept *nm = (void *)msg; 421 422 lwkt_replymsg(&msg->nm_lmsg, nm->nm_prufn(nm->nm_so, nm->nm_nam)); 423 } 424 #endif 425 426 void 427 netmsg_pru_attach(netmsg_t msg) 428 { 429 struct netmsg_pru_attach *nm = (void *)msg; 430 431 lwkt_replymsg(&msg->nm_lmsg, 432 nm->nm_prufn(nm->nm_so, nm->nm_proto, nm->nm_ai)); 433 } 434 435 void 436 netmsg_pru_bind(netmsg_t msg) 437 { 438 struct netmsg_pru_bind *nm = (void *)msg; 439 440 lwkt_replymsg(&msg->nm_lmsg, 441 nm->nm_prufn(nm->nm_so, nm->nm_nam, nm->nm_td)); 442 } 443 444 void 445 netmsg_pru_connect(netmsg_t msg) 446 { 447 struct netmsg_pru_connect *nm = (void *)msg; 448 449 lwkt_replymsg(&msg->nm_lmsg, 450 nm->nm_prufn(nm->nm_so, nm->nm_nam, nm->nm_td)); 451 } 452 453 void 454 netmsg_pru_connect2(netmsg_t msg) 455 { 456 struct netmsg_pru_connect2 *nm = (void *)msg; 457 458 lwkt_replymsg(&msg->nm_lmsg, nm->nm_prufn(nm->nm_so1, nm->nm_so2)); 459 } 460 461 void 462 netmsg_pru_control(netmsg_t msg) 463 { 464 struct netmsg_pru_control *nm = (void *)msg; 465 int error; 466 467 error = nm->nm_prufn(nm->nm_so, nm->nm_cmd, nm->nm_data, 468 nm->nm_ifp, nm->nm_td); 469 lwkt_replymsg(&msg->nm_lmsg, error); 470 } 471 472 void 473 netmsg_pru_detach(netmsg_t msg) 474 { 475 struct netmsg_pru_detach *nm = (void *)msg; 476 477 lwkt_replymsg(&msg->nm_lmsg, nm->nm_prufn(nm->nm_so)); 478 } 479 480 void 481 netmsg_pru_disconnect(netmsg_t msg) 482 { 483 struct netmsg_pru_disconnect *nm = (void *)msg; 484 485 lwkt_replymsg(&msg->nm_lmsg, nm->nm_prufn(nm->nm_so)); 486 } 487 488 void 489 netmsg_pru_listen(netmsg_t msg) 490 { 491 struct netmsg_pru_listen *nm = (void *)msg; 492 493 lwkt_replymsg(&msg->nm_lmsg, nm->nm_prufn(nm->nm_so, nm->nm_td)); 494 } 495 496 void 497 netmsg_pru_peeraddr(netmsg_t msg) 498 { 499 struct netmsg_pru_peeraddr *nm = (void *)msg; 500 501 lwkt_replymsg(&msg->nm_lmsg, nm->nm_prufn(nm->nm_so, nm->nm_nam)); 502 } 503 504 void 505 netmsg_pru_rcvd(netmsg_t msg) 506 { 507 struct netmsg_pru_rcvd *nm = (void *)msg; 508 509 lwkt_replymsg(&msg->nm_lmsg, nm->nm_prufn(nm->nm_so, nm->nm_flags)); 510 } 511 512 void 513 netmsg_pru_rcvoob(netmsg_t msg) 514 { 515 struct netmsg_pru_rcvoob *nm = (void *)msg; 516 517 lwkt_replymsg(&msg->nm_lmsg, 518 nm->nm_prufn(nm->nm_so, nm->nm_m, nm->nm_flags)); 519 } 520 521 void 522 netmsg_pru_send(netmsg_t msg) 523 { 524 struct netmsg_pru_send *nm = (void *)msg; 525 int error; 526 527 error = nm->nm_prufn(nm->nm_so, nm->nm_flags, nm->nm_m, 528 nm->nm_addr, nm->nm_control, nm->nm_td); 529 lwkt_replymsg(&msg->nm_lmsg, error); 530 } 531 532 void 533 netmsg_pru_sense(netmsg_t msg) 534 { 535 struct netmsg_pru_sense *nm = (void *)msg; 536 537 lwkt_replymsg(&msg->nm_lmsg, nm->nm_prufn(nm->nm_so, nm->nm_stat)); 538 } 539 540 void 541 netmsg_pru_shutdown(netmsg_t msg) 542 { 543 struct netmsg_pru_shutdown *nm = (void *)msg; 544 545 lwkt_replymsg(&msg->nm_lmsg, nm->nm_prufn(nm->nm_so)); 546 } 547 548 void 549 netmsg_pru_sockaddr(netmsg_t msg) 550 { 551 struct netmsg_pru_sockaddr *nm = (void *)msg; 552 553 lwkt_replymsg(&msg->nm_lmsg, nm->nm_prufn(nm->nm_so, nm->nm_nam)); 554 } 555 556 void 557 netmsg_pru_sopoll(netmsg_t msg) 558 { 559 struct netmsg_pru_sopoll *nm = (void *)msg; 560 int error; 561 562 error = nm->nm_prufn(nm->nm_so, nm->nm_events, nm->nm_cred, nm->nm_td); 563 lwkt_replymsg(&msg->nm_lmsg, error); 564 } 565 566 void 567 netmsg_pr_ctloutput(netmsg_t msg) 568 { 569 struct netmsg_pr_ctloutput *nm = (void *)msg; 570 571 lwkt_replymsg(&msg->nm_lmsg, nm->nm_prfn(nm->nm_so, nm->nm_sopt)); 572 } 573 574 void 575 netmsg_pr_timeout(netmsg_t msg) 576 { 577 struct netmsg_pr_timeout *nm = (void *)msg; 578 579 lwkt_replymsg(&msg->nm_lmsg, nm->nm_prfn()); 580 } 581 582 /* 583 * Handle a predicate event request. This function is only called once 584 * when the predicate message queueing request is received. 585 */ 586 void 587 netmsg_so_notify(netmsg_t netmsg) 588 { 589 struct netmsg_so_notify *msg = (void *)netmsg; 590 struct signalsockbuf *ssb; 591 592 ssb = (msg->nm_etype & NM_REVENT) ? 593 &msg->nm_so->so_rcv : 594 &msg->nm_so->so_snd; 595 596 /* 597 * Reply immediately if the event has occured, otherwise queue the 598 * request. 599 */ 600 if (msg->nm_predicate(&msg->nm_netmsg)) { 601 lwkt_replymsg(&msg->nm_netmsg.nm_lmsg, 602 msg->nm_netmsg.nm_lmsg.ms_error); 603 } else { 604 TAILQ_INSERT_TAIL(&ssb->ssb_sel.si_mlist, msg, nm_list); 605 ssb->ssb_flags |= SSB_MEVENT; 606 } 607 } 608 609 /* 610 * Called by doio when trying to abort a netmsg_so_notify message. 611 * Unlike the other functions this one is dispatched directly by 612 * the LWKT subsystem, so it takes a lwkt_msg_t as an argument. 613 * 614 * The original message, lmsg, is under the control of the caller and 615 * will not be destroyed until we return so we can safely reference it 616 * in our synchronous abort request. 617 * 618 * This part of the abort request occurs on the originating cpu which 619 * means we may race the message flags and the original message may 620 * not even have been processed by the target cpu yet. 621 */ 622 void 623 netmsg_so_notify_doabort(lwkt_msg_t lmsg) 624 { 625 struct netmsg_so_notify_abort msg; 626 627 if ((lmsg->ms_flags & (MSGF_DONE | MSGF_REPLY)) == 0) { 628 netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0, 629 netmsg_so_notify_abort); 630 msg.nm_notifymsg = (void *)lmsg; 631 lwkt_domsg(lmsg->ms_target_port, &msg.nm_netmsg.nm_lmsg, 0); 632 } 633 } 634 635 /* 636 * Predicate requests can be aborted. This function is only called once 637 * and will interlock against processing/reply races (since such races 638 * occur on the same thread that controls the port where the abort is 639 * requeued). 640 * 641 * This part of the abort request occurs on the target cpu. The message 642 * flags must be tested again in case the test that we did on the 643 * originating cpu raced. Since messages are handled in sequence, the 644 * original message will have already been handled by the loop and either 645 * replied to or queued. 646 * 647 * We really only need to interlock with MSGF_REPLY (a bit that is set on 648 * our cpu when we reply). Note that MSGF_DONE is not set until the 649 * reply reaches the originating cpu. Test both bits anyway. 650 */ 651 void 652 netmsg_so_notify_abort(netmsg_t netmsg) 653 { 654 struct netmsg_so_notify_abort *abrtmsg = (void *)netmsg; 655 struct netmsg_so_notify *msg = abrtmsg->nm_notifymsg; 656 struct signalsockbuf *ssb; 657 658 /* 659 * The original notify message is not destroyed until after the 660 * abort request is returned, so we can check its state. 661 */ 662 if ((msg->nm_netmsg.nm_lmsg.ms_flags & (MSGF_DONE | MSGF_REPLY)) == 0) { 663 ssb = (msg->nm_etype & NM_REVENT) ? 664 &msg->nm_so->so_rcv : 665 &msg->nm_so->so_snd; 666 TAILQ_REMOVE(&ssb->ssb_sel.si_mlist, msg, nm_list); 667 lwkt_replymsg(&msg->nm_netmsg.nm_lmsg, EINTR); 668 } 669 670 /* 671 * Reply to the abort message 672 */ 673 lwkt_replymsg(&abrtmsg->nm_netmsg.nm_lmsg, 0); 674 } 675 676