kernel/fs/sockfs/sockcommon.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Copyright 2017 Sebastian Wiedenroth
  25  */
  26
  27 #include <sys/types.h>
  28 #include <sys/param.h>
  29 #include <sys/systm.h>
  30 #include <sys/sysmacros.h>
  31 #include <sys/debug.h>
  32 #include <sys/cmn_err.h>
  33 #include <sys/vfs.h>
  34 #include <sys/policy.h>
  35 #include <sys/modctl.h>
  36
  37 #include <sys/sunddi.h>
  38
  39 #include <sys/strsun.h>
  40 #include <sys/stropts.h>
  41 #include <sys/strsubr.h>
  42 #include <sys/socket.h>
  43 #include <sys/socketvar.h>
  44 #include <sys/uio.h>
  45
  46 #include <inet/ipclassifier.h>
  47 #include "sockcommon.h"
  48 #include "sockfilter_impl.h"
  49 #include "socktpi.h"
  50 #include "sodirect.h"
  51 #include <inet/ip.h>
  52
  53 extern int xnet_skip_checks, xnet_check_print, xnet_truncate_print;
  54
  55 /*
  56  * Common socket access functions.
  57  *
  58  * Instead of accessing the sonode switch directly (i.e., SOP_xxx()),
  59  * the socket_xxx() function should be used.
  60  */
  61
  62 /*
  63  * Try to create a new sonode of the requested <family, type, protocol>.
  64  */
  65 /* ARGSUSED */
  66 struct sonode *
  67 socket_create(int family, int type, int protocol, char *devpath, char *mod,
  68     int flags, struct cred *cr, int *errorp)
  69 {
  70         struct sonode *so;
  71         struct sockparams *sp = NULL;
  72         int saved_error;
  73
  74         /*
  75          * Look for a sockparams entry that match the given criteria.
  76          * solookup() returns with the entry held.
  77          */
  78         *errorp = solookup(family, type, protocol, &sp);
  79         saved_error = *errorp;
  80         if (sp == NULL) {
  81                 int kmflags = (flags == SOCKET_SLEEP) ? KM_SLEEP : KM_NOSLEEP;
  82                 /*
  83                  * There is no matching sockparams entry. An ephemeral entry is
  84                  * created if the caller specifies a device or a socket module.
  85                  */
  86                 if (devpath != NULL) {
  87                         saved_error = 0;
  88                         sp = sockparams_hold_ephemeral_bydev(family, type,
  89                             protocol, devpath, kmflags, errorp);
  90                 } else if (mod != NULL) {
  91                         saved_error = 0;
  92                         sp = sockparams_hold_ephemeral_bymod(family, type,
  93                             protocol, mod, kmflags, errorp);
  94                 } else {
  95                         *errorp = solookup(family, type, 0, &sp);
  96                 }
  97
  98                 if (sp == NULL) {
  99                         if (saved_error && (*errorp == EPROTONOSUPPORT ||
 100                             *errorp == EPROTOTYPE || *errorp == ENOPROTOOPT))
 101                                 *errorp = saved_error;
 102                         return (NULL);
 103                 }
 104         }
 105
 106         ASSERT(sp->sp_smod_info != NULL);
 107         ASSERT(flags == SOCKET_SLEEP || flags == SOCKET_NOSLEEP);
 108         sp->sp_stats.sps_ncreate.value.ui64++;
 109         so = sp->sp_smod_info->smod_sock_create_func(sp, family, type,
 110             protocol, flags, errorp, cr);
 111         if (so == NULL) {
 112                 SOCKPARAMS_DEC_REF(sp);
 113         } else {
 114                 if ((*errorp = SOP_INIT(so, NULL, cr, flags)) == 0) {
 115                         /* Cannot fail, only bumps so_count */
 116                         (void) fop_open(&SOTOV(so), FREAD|FWRITE, cr, NULL);
 117                 } else {
 118                         if (saved_error && (*errorp == EPROTONOSUPPORT ||
 119                             *errorp == EPROTOTYPE || *errorp == ENOPROTOOPT))
 120                                 *errorp = saved_error;
 121                         socket_destroy(so);
 122                         so = NULL;
 123                 }
 124         }
 125         return (so);
 126 }
 127
 128 struct sonode *
 129 socket_newconn(struct sonode *parent, sock_lower_handle_t lh,
 130     sock_downcalls_t *dc, int flags, int *errorp)
 131 {
 132         struct sonode *so;
 133         struct sockparams *sp;
 134         struct cred *cr;
 135
 136         if ((cr = CRED()) == NULL)
 137                 cr = kcred;
 138
 139         sp = parent->so_sockparams;
 140         ASSERT(sp != NULL);
 141
 142         sp->sp_stats.sps_ncreate.value.ui64++;
 143         so = sp->sp_smod_info->smod_sock_create_func(sp, parent->so_family,
 144             parent->so_type, parent->so_protocol, flags, errorp, cr);
 145         if (so != NULL) {
 146                 SOCKPARAMS_INC_REF(sp);
 147
 148                 so->so_proto_handle = lh;
 149                 so->so_downcalls = dc;
 150                 /*
 151                  * This function may be called in interrupt context, and CRED()
 152                  * will be NULL. In this case, pass in kcred.
 153                  */
 154                 if ((*errorp = SOP_INIT(so, parent, cr, flags)) == 0) {
 155                         /* Cannot fail, only bumps so_count */
 156                         (void) fop_open(&SOTOV(so), FREAD|FWRITE, cr, NULL);
 157                 } else  {
 158                         socket_destroy(so);
 159                         so = NULL;
 160                 }
 161         }
 162
 163         return (so);
 164 }
 165
 166 /*
 167  * Bind local endpoint.
 168  */
 169 int
 170 socket_bind(struct sonode *so, struct sockaddr *name, socklen_t namelen,
 171     int flags, cred_t *cr)
 172 {
 173         return (SOP_BIND(so, name, namelen, flags, cr));
 174 }
 175
 176 /*
 177  * Turn socket into a listen socket.
 178  */
 179 int
 180 socket_listen(struct sonode *so, int backlog, cred_t *cr)
 181 {
 182         if (backlog < 0) {
 183                 backlog = 0;
 184         }
 185
 186         /*
 187          * Use the same qlimit as in BSD. BSD checks the qlimit
 188          * before queuing the next connection implying that a
 189          * listen(sock, 0) allows one connection to be queued.
 190          * BSD also uses 1.5 times the requested backlog.
 191          *
 192          * XNS Issue 4 required a strict interpretation of the backlog.
 193          * This has been waived subsequently for Issue 4 and the change
 194          * incorporated in XNS Issue 5. So we aren't required to do
 195          * anything special for XPG apps.
 196          */
 197         if (backlog >= (INT_MAX - 1) / 3)
 198                 backlog = INT_MAX;
 199         else
 200                 backlog = backlog * 3 / 2 + 1;
 201
 202         return (SOP_LISTEN(so, backlog, cr));
 203 }
 204
 205 /*
 206  * Accept incoming connection.
 207  */
 208 int
 209 socket_accept(struct sonode *lso, int fflag, cred_t *cr, struct sonode **nsop)
 210 {
 211         return (SOP_ACCEPT(lso, fflag, cr, nsop));
 212 }
 213
 214 /*
 215  * Active open.
 216  */
 217 int
 218 socket_connect(struct sonode *so, struct sockaddr *name,
 219     socklen_t namelen, int fflag, int flags, cred_t *cr)
 220 {
 221         int error;
 222
 223         /*
 224          * Handle a connect to a name parameter of type AF_UNSPEC like a
 225          * connect to a null address. This is the portable method to
 226          * unconnect a socket.
 227          */
 228         if ((namelen >= sizeof (sa_family_t)) &&
 229             (name->sa_family == AF_UNSPEC)) {
 230                 name = NULL;
 231                 namelen = 0;
 232         }
 233
 234         error = SOP_CONNECT(so, name, namelen, fflag, flags, cr);
 235
 236         return (error);
 237 }
 238
 239 /*
 240  * Get address of remote node.
 241  */
 242 int
 243 socket_getpeername(struct sonode *so, struct sockaddr *addr,
 244     socklen_t *addrlen, boolean_t accept, cred_t *cr)
 245 {
 246         ASSERT(*addrlen > 0);
 247         return (SOP_GETPEERNAME(so, addr, addrlen, accept, cr));
 248
 249 }
 250
 251 /*
 252  * Get local address.
 253  */
 254 int
 255 socket_getsockname(struct sonode *so, struct sockaddr *addr,
 256     socklen_t *addrlen, cred_t *cr)
 257 {
 258         return (SOP_GETSOCKNAME(so, addr, addrlen, cr));
 259
 260 }
 261
 262 /*
 263  * Called from shutdown().
 264  */
 265 int
 266 socket_shutdown(struct sonode *so, int how, cred_t *cr)
 267 {
 268         return (SOP_SHUTDOWN(so, how, cr));
 269 }
 270
 271 /*
 272  * Get socket options.
 273  */
 274 /*ARGSUSED*/
 275 int
 276 socket_getsockopt(struct sonode *so, int level, int option_name,
 277     void *optval, socklen_t *optlenp, int flags, cred_t *cr)
 278 {
 279         return (SOP_GETSOCKOPT(so, level, option_name, optval,
 280             optlenp, flags, cr));
 281 }
 282
 283 /*
 284  * Set socket options
 285  */
 286 int
 287 socket_setsockopt(struct sonode *so, int level, int option_name,
 288     const void *optval, t_uscalar_t optlen, cred_t *cr)
 289 {
 290         int val = 1;
 291         /* Caller allocates aligned optval, or passes null */
 292         ASSERT(((uintptr_t)optval & (sizeof (t_scalar_t) - 1)) == 0);
 293         /* If optval is null optlen is 0, and vice-versa */
 294         ASSERT(optval != NULL || optlen == 0);
 295         ASSERT(optlen != 0 || optval == NULL);
 296
 297         if (optval == NULL && optlen == 0)
 298                 optval = &val;
 299
 300         return (SOP_SETSOCKOPT(so, level, option_name, optval, optlen, cr));
 301 }
 302
 303 int
 304 socket_sendmsg(struct sonode *so, struct msghdr *msg, struct uio *uiop,
 305     cred_t *cr)
 306 {
 307         int error = 0;
 308         ssize_t orig_resid = uiop->uio_resid;
 309
 310         /*
 311          * Do not bypass the cache if we are doing a local (AF_UNIX) write.
 312          */
 313         if (so->so_family == AF_UNIX)
 314                 uiop->uio_extflg |= UIO_COPY_CACHED;
 315         else
 316                 uiop->uio_extflg &= ~UIO_COPY_CACHED;
 317
 318         error = SOP_SENDMSG(so, msg, uiop, cr);
 319         switch (error) {
 320         default:
 321                 break;
 322         case EINTR:
 323         case ENOMEM:
 324         /* EAGAIN is EWOULDBLOCK */
 325         case EWOULDBLOCK:
 326                 /* We did a partial send */
 327                 if (uiop->uio_resid != orig_resid)
 328                         error = 0;
 329                 break;
 330         case EPIPE:
 331                 if (((so->so_mode & SM_KERNEL) == 0) &&
 332                     ((msg->msg_flags & MSG_NOSIGNAL) == 0)) {
 333                         tsignal(curthread, SIGPIPE);
 334                 }
 335                 break;
 336         }
 337
 338         return (error);
 339 }
 340
 341 int
 342 socket_sendmblk(struct sonode *so, struct msghdr *msg, int fflag,
 343     struct cred *cr, mblk_t **mpp)
 344 {
 345         int error = 0;
 346
 347         error = SOP_SENDMBLK(so, msg, fflag, cr, mpp);
 348         if (error == EPIPE) {
 349                 tsignal(curthread, SIGPIPE);
 350         }
 351         return (error);
 352 }
 353
 354 int
 355 socket_recvmsg(struct sonode *so, struct msghdr *msg, struct uio *uiop,
 356     cred_t *cr)
 357 {
 358         int error;
 359         ssize_t orig_resid = uiop->uio_resid;
 360
 361         /*
 362          * Do not bypass the cache when reading data, as the application
 363          * is likely to access the data shortly.
 364          */
 365         uiop->uio_extflg |= UIO_COPY_CACHED;
 366
 367         error = SOP_RECVMSG(so, msg, uiop, cr);
 368
 369         switch (error) {
 370         case EINTR:
 371         /* EAGAIN is EWOULDBLOCK */
 372         case EWOULDBLOCK:
 373                 /* We did a partial read */
 374                 if (uiop->uio_resid != orig_resid)
 375                         error = 0;
 376                 break;
 377         default:
 378                 break;
 379         }
 380         return (error);
 381 }
 382
 383 int
 384 socket_ioctl(struct sonode *so, int cmd, intptr_t arg, int mode,
 385     struct cred *cr, int32_t *rvalp)
 386 {
 387         return (SOP_IOCTL(so, cmd, arg, mode, cr, rvalp));
 388 }
 389
 390 int
 391 socket_poll(struct sonode *so, short events, int anyyet, short *reventsp,
 392     struct pollhead **phpp)
 393 {
 394         return (SOP_POLL(so, events, anyyet, reventsp, phpp));
 395 }
 396
 397 int
 398 socket_close(struct sonode *so, int flag, struct cred *cr)
 399 {
 400         return (fop_close(SOTOV(so), flag, 1, 0, cr, NULL));
 401 }
 402
 403 int
 404 socket_close_internal(struct sonode *so, int flag, cred_t *cr)
 405 {
 406         ASSERT(so->so_count == 0);
 407
 408         return (SOP_CLOSE(so, flag, cr));
 409 }
 410
 411 void
 412 socket_destroy(struct sonode *so)
 413 {
 414         vn_invalid(SOTOV(so));
 415         VN_RELE(SOTOV(so));
 416 }
 417
 418 /* ARGSUSED */
 419 void
 420 socket_destroy_internal(struct sonode *so, cred_t *cr)
 421 {
 422         struct sockparams *sp = so->so_sockparams;
 423         ASSERT(so->so_count == 0 && sp != NULL);
 424
 425         sp->sp_smod_info->smod_sock_destroy_func(so);
 426
 427         SOCKPARAMS_DEC_REF(sp);
 428 }
 429
 430 /*
 431  * TODO Once the common vnode ops is available, then the vnops argument
 432  * should be removed.
 433  */
 434 /*ARGSUSED*/
 435 int
 436 sonode_constructor(void *buf, void *cdrarg, int kmflags)
 437 {
 438         struct sonode *so = buf;
 439         struct vnode *vp;
 440
 441         vp = so->so_vnode = vn_alloc(kmflags);
 442         if (vp == NULL) {
 443                 return (-1);
 444         }
 445         vp->v_data = so;
 446         vn_setops(vp, &socket_vnodeops);
 447
 448         so->so_priv             = NULL;
 449         so->so_oobmsg           = NULL;
 450
 451         so->so_proto_handle     = NULL;
 452
 453         so->so_peercred         = NULL;
 454
 455         so->so_rcv_queued       = 0;
 456         so->so_rcv_q_head       = NULL;
 457         so->so_rcv_q_last_head  = NULL;
 458         so->so_rcv_head         = NULL;
 459         so->so_rcv_last_head    = NULL;
 460         so->so_rcv_wanted       = 0;
 461         so->so_rcv_timer_interval = SOCKET_NO_RCVTIMER;
 462         so->so_rcv_timer_tid    = 0;
 463         so->so_rcv_thresh       = 0;
 464
 465         list_create(&so->so_acceptq_list, sizeof (struct sonode),
 466             offsetof(struct sonode, so_acceptq_node));
 467         list_create(&so->so_acceptq_defer, sizeof (struct sonode),
 468             offsetof(struct sonode, so_acceptq_node));
 469         list_link_init(&so->so_acceptq_node);
 470         so->so_acceptq_len      = 0;
 471         so->so_backlog          = 0;
 472         so->so_listener         = NULL;
 473
 474         so->so_snd_qfull        = B_FALSE;
 475
 476         so->so_filter_active    = 0;
 477         so->so_filter_tx        = 0;
 478         so->so_filter_defertime = 0;
 479         so->so_filter_top       = NULL;
 480         so->so_filter_bottom    = NULL;
 481
 482         mutex_init(&so->so_lock, NULL, MUTEX_DEFAULT, NULL);
 483         mutex_init(&so->so_acceptq_lock, NULL, MUTEX_DEFAULT, NULL);
 484         rw_init(&so->so_fallback_rwlock, NULL, RW_DEFAULT, NULL);
 485         cv_init(&so->so_state_cv, NULL, CV_DEFAULT, NULL);
 486         cv_init(&so->so_single_cv, NULL, CV_DEFAULT, NULL);
 487         cv_init(&so->so_read_cv, NULL, CV_DEFAULT, NULL);
 488
 489         cv_init(&so->so_acceptq_cv, NULL, CV_DEFAULT, NULL);
 490         cv_init(&so->so_snd_cv, NULL, CV_DEFAULT, NULL);
 491         cv_init(&so->so_rcv_cv, NULL, CV_DEFAULT, NULL);
 492         cv_init(&so->so_copy_cv, NULL, CV_DEFAULT, NULL);
 493         cv_init(&so->so_closing_cv, NULL, CV_DEFAULT, NULL);
 494
 495         return (0);
 496 }
 497
 498 /*ARGSUSED*/
 499 void
 500 sonode_destructor(void *buf, void *cdrarg)
 501 {
 502         struct sonode *so = buf;
 503         struct vnode *vp = SOTOV(so);
 504
 505         ASSERT(so->so_priv == NULL);
 506         ASSERT(so->so_peercred == NULL);
 507
 508         ASSERT(so->so_oobmsg == NULL);
 509
 510         ASSERT(so->so_rcv_q_head == NULL);
 511
 512         list_destroy(&so->so_acceptq_list);
 513         list_destroy(&so->so_acceptq_defer);
 514         ASSERT(!list_link_active(&so->so_acceptq_node));
 515         ASSERT(so->so_listener == NULL);
 516
 517         ASSERT(so->so_filter_active == 0);
 518         ASSERT(so->so_filter_tx == 0);
 519         ASSERT(so->so_filter_top == NULL);
 520         ASSERT(so->so_filter_bottom == NULL);
 521
 522         ASSERT(vp->v_data == so);
 523         ASSERT(vn_matchops(vp, &socket_vnodeops));
 524
 525         vn_free(vp);
 526
 527         mutex_destroy(&so->so_lock);
 528         mutex_destroy(&so->so_acceptq_lock);
 529         rw_destroy(&so->so_fallback_rwlock);
 530
 531         cv_destroy(&so->so_state_cv);
 532         cv_destroy(&so->so_single_cv);
 533         cv_destroy(&so->so_read_cv);
 534         cv_destroy(&so->so_acceptq_cv);
 535         cv_destroy(&so->so_snd_cv);
 536         cv_destroy(&so->so_rcv_cv);
 537         cv_destroy(&so->so_closing_cv);
 538 }
 539
 540 void
 541 sonode_init(struct sonode *so, struct sockparams *sp, int family,
 542     int type, int protocol, sonodeops_t *sops)
 543 {
 544         vnode_t *vp;
 545
 546         vp = SOTOV(so);
 547
 548         so->so_flag     = 0;
 549
 550         so->so_state    = 0;
 551         so->so_mode     = 0;
 552
 553         so->so_count    = 0;
 554
 555         so->so_family   = family;
 556         so->so_type     = type;
 557         so->so_protocol = protocol;
 558
 559         SOCK_CONNID_INIT(so->so_proto_connid);
 560
 561         so->so_options  = 0;
 562         so->so_linger.l_onoff   = 0;
 563         so->so_linger.l_linger = 0;
 564         so->so_sndbuf   = 0;
 565         so->so_error    = 0;
 566         so->so_rcvtimeo = 0;
 567         so->so_sndtimeo = 0;
 568
 569         ASSERT(so->so_oobmsg == NULL);
 570         so->so_oobmark  = 0;
 571         so->so_pgrp     = 0;
 572
 573         ASSERT(so->so_peercred == NULL);
 574
 575         so->so_zoneid = getzoneid();
 576
 577         so->so_sockparams = sp;
 578
 579         so->so_ops = sops;
 580
 581         so->so_not_str = (sops != &sotpi_sonodeops);
 582
 583         so->so_proto_handle = NULL;
 584
 585         so->so_downcalls = NULL;
 586
 587         so->so_copyflag = 0;
 588
 589         vn_reinit(vp);
 590         vp->v_vfsp      = rootvfs;
 591         vp->v_type      = VSOCK;
 592         vp->v_rdev      = sockdev;
 593
 594         so->so_snd_qfull = B_FALSE;
 595         so->so_minpsz = 0;
 596
 597         so->so_rcv_wakeup = B_FALSE;
 598         so->so_snd_wakeup = B_FALSE;
 599         so->so_flowctrld = B_FALSE;
 600
 601         so->so_pollev = 0;
 602         bzero(&so->so_poll_list, sizeof (so->so_poll_list));
 603         bzero(&so->so_proto_props, sizeof (struct sock_proto_props));
 604
 605         bzero(&(so->so_ksock_callbacks), sizeof (ksocket_callbacks_t));
 606         so->so_ksock_cb_arg = NULL;
 607
 608         so->so_max_addr_len = sizeof (struct sockaddr_storage);
 609
 610         so->so_direct = NULL;
 611
 612         vn_exists(vp);
 613 }
 614
 615 void
 616 sonode_fini(struct sonode *so)
 617 {
 618         vnode_t *vp;
 619
 620         ASSERT(so->so_count == 0);
 621
 622         if (so->so_rcv_timer_tid) {
 623                 ASSERT(MUTEX_NOT_HELD(&so->so_lock));
 624                 (void) untimeout(so->so_rcv_timer_tid);
 625                 so->so_rcv_timer_tid = 0;
 626         }
 627
 628         if (so->so_poll_list.ph_list != NULL) {
 629                 pollwakeup(&so->so_poll_list, POLLERR);
 630                 pollhead_clean(&so->so_poll_list);
 631         }
 632
 633         if (so->so_direct != NULL)
 634                 sod_sock_fini(so);
 635
 636         vp = SOTOV(so);
 637         vn_invalid(vp);
 638
 639         if (so->so_peercred != NULL) {
 640                 crfree(so->so_peercred);
 641                 so->so_peercred = NULL;
 642         }
 643         /* Detach and destroy filters */
 644         if (so->so_filter_top != NULL)
 645                 sof_sonode_cleanup(so);
 646
 647         ASSERT(list_is_empty(&so->so_acceptq_list));
 648         ASSERT(list_is_empty(&so->so_acceptq_defer));
 649         ASSERT(!list_link_active(&so->so_acceptq_node));
 650
 651         ASSERT(so->so_rcv_queued == 0);
 652         ASSERT(so->so_rcv_q_head == NULL);
 653         ASSERT(so->so_rcv_q_last_head == NULL);
 654         ASSERT(so->so_rcv_head == NULL);
 655         ASSERT(so->so_rcv_last_head == NULL);
 656 }