Print this page
    
9042 multiples of tty streams modules cause weirdness
Reviewed by: Randy Fishel <randyf@sibernet.com>
Reviewed by: Carlos Neira <cneirabustos@gmail.com>
Approved by: Hans Rosenfeld <rosenfeld@grumpf.hope-2000.org>
    
      
        | Split | 
	Close | 
      
      | Expand all | 
      | Collapse all | 
    
    
          --- old/usr/src/uts/common/os/streamio.c
          +++ new/usr/src/uts/common/os/streamio.c
   1    1  /*
   2    2   * CDDL HEADER START
   3    3   *
   4    4   * The contents of this file are subject to the terms of the
   5    5   * Common Development and Distribution License (the "License").
   6    6   * You may not use this file except in compliance with the License.
   7    7   *
   8    8   * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9    9   * or http://www.opensolaris.org/os/licensing.
  10   10   * See the License for the specific language governing permissions
  11   11   * and limitations under the License.
  12   12   *
  13   13   * When distributing Covered Code, include this CDDL HEADER in each
  14   14   * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15   15   * If applicable, add the following below this CDDL HEADER, with the
  16   16   * fields enclosed by brackets "[]" replaced with your own identifying
  17   17   * information: Portions Copyright [yyyy] [name of copyright owner]
  
    | 
      ↓ open down ↓ | 
    17 lines elided | 
    
      ↑ open up ↑ | 
  
  18   18   *
  19   19   * CDDL HEADER END
  20   20   */
  21   21  /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  22   22  /*        All Rights Reserved   */
  23   23  
  24   24  
  25   25  /*
  26   26   * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
  27   27   * Copyright 2017 Joyent, Inc.
       28 + * Copyright 2018 OmniOS Community Edition (OmniOSce) Association.
  28   29   */
  29   30  
  30   31  #include <sys/types.h>
  31   32  #include <sys/sysmacros.h>
  32   33  #include <sys/param.h>
  33   34  #include <sys/errno.h>
  34   35  #include <sys/signal.h>
  35   36  #include <sys/stat.h>
  36   37  #include <sys/proc.h>
  37   38  #include <sys/cred.h>
  38   39  #include <sys/user.h>
  39   40  #include <sys/vnode.h>
  40   41  #include <sys/file.h>
  41   42  #include <sys/stream.h>
  42   43  #include <sys/strsubr.h>
  43   44  #include <sys/stropts.h>
  44   45  #include <sys/tihdr.h>
  45   46  #include <sys/var.h>
  46   47  #include <sys/poll.h>
  47   48  #include <sys/termio.h>
  48   49  #include <sys/ttold.h>
  49   50  #include <sys/systm.h>
  50   51  #include <sys/uio.h>
  51   52  #include <sys/cmn_err.h>
  52   53  #include <sys/sad.h>
  53   54  #include <sys/netstack.h>
  54   55  #include <sys/priocntl.h>
  55   56  #include <sys/jioctl.h>
  56   57  #include <sys/procset.h>
  57   58  #include <sys/session.h>
  58   59  #include <sys/kmem.h>
  59   60  #include <sys/filio.h>
  60   61  #include <sys/vtrace.h>
  61   62  #include <sys/debug.h>
  62   63  #include <sys/strredir.h>
  63   64  #include <sys/fs/fifonode.h>
  64   65  #include <sys/fs/snode.h>
  65   66  #include <sys/strlog.h>
  66   67  #include <sys/strsun.h>
  67   68  #include <sys/project.h>
  68   69  #include <sys/kbio.h>
  69   70  #include <sys/msio.h>
  70   71  #include <sys/tty.h>
  71   72  #include <sys/ptyvar.h>
  72   73  #include <sys/vuid_event.h>
  73   74  #include <sys/modctl.h>
  74   75  #include <sys/sunddi.h>
  75   76  #include <sys/sunldi_impl.h>
  76   77  #include <sys/autoconf.h>
  77   78  #include <sys/policy.h>
  78   79  #include <sys/dld.h>
  79   80  #include <sys/zone.h>
  80   81  #include <c2/audit.h>
  81   82  
  82   83  /*
  83   84   * This define helps improve the readability of streams code while
  84   85   * still maintaining a very old streams performance enhancement.  The
  85   86   * performance enhancement basically involved having all callers
  86   87   * of straccess() perform the first check that straccess() will do
  87   88   * locally before actually calling straccess().  (There by reducing
  88   89   * the number of unnecessary calls to straccess().)
  89   90   */
  90   91  #define i_straccess(x, y)       ((stp->sd_sidp == NULL) ? 0 : \
  91   92                                      (stp->sd_vnode->v_type == VFIFO) ? 0 : \
  92   93                                      straccess((x), (y)))
  93   94  
  94   95  /*
  95   96   * what is mblk_pull_len?
  96   97   *
  97   98   * If a streams message consists of many short messages,
  98   99   * a performance degradation occurs from copyout overhead.
  99  100   * To decrease the per mblk overhead, messages that are
 100  101   * likely to consist of many small mblks are pulled up into
 101  102   * one continuous chunk of memory.
 102  103   *
 103  104   * To avoid the processing overhead of examining every
 104  105   * mblk, a quick heuristic is used. If the first mblk in
 105  106   * the message is shorter than mblk_pull_len, it is likely
 106  107   * that the rest of the mblk will be short.
 107  108   *
 108  109   * This heuristic was decided upon after performance tests
 109  110   * indicated that anything more complex slowed down the main
 110  111   * code path.
 111  112   */
 112  113  #define MBLK_PULL_LEN 64
 113  114  uint32_t mblk_pull_len = MBLK_PULL_LEN;
 114  115  
 115  116  /*
 116  117   * The sgttyb_handling flag controls the handling of the old BSD
 117  118   * TIOCGETP, TIOCSETP, and TIOCSETN ioctls as follows:
 118  119   *
 119  120   * 0 - Emit no warnings at all and retain old, broken behavior.
 120  121   * 1 - Emit no warnings and silently handle new semantics.
 121  122   * 2 - Send cmn_err(CE_NOTE) when either TIOCSETP or TIOCSETN is used
 122  123   *     (once per system invocation).  Handle with new semantics.
 123  124   * 3 - Send SIGSYS when any TIOCGETP, TIOCSETP, or TIOCSETN call is
 124  125   *     made (so that offenders drop core and are easy to debug).
 125  126   *
 126  127   * The "new semantics" are that TIOCGETP returns B38400 for
 127  128   * sg_[io]speed if the corresponding value is over B38400, and that
 128  129   * TIOCSET[PN] accept B38400 in these cases to mean "retain current
 129  130   * bit rate."
 130  131   */
 131  132  int sgttyb_handling = 1;
 132  133  static boolean_t sgttyb_complaint;
 133  134  
 134  135  /* don't push drcompat module by default on Style-2 streams */
 135  136  static int push_drcompat = 0;
 136  137  
 137  138  /*
 138  139   * id value used to distinguish between different ioctl messages
 139  140   */
 140  141  static uint32_t ioc_id;
 141  142  
 142  143  static void putback(struct stdata *, queue_t *, mblk_t *, int);
 143  144  static void strcleanall(struct vnode *);
 144  145  static int strwsrv(queue_t *);
 145  146  static int strdocmd(struct stdata *, struct strcmd *, cred_t *);
 146  147  
 147  148  /*
 148  149   * qinit and module_info structures for stream head read and write queues
 149  150   */
 150  151  struct module_info strm_info = { 0, "strrhead", 0, INFPSZ, STRHIGH, STRLOW };
 151  152  struct module_info stwm_info = { 0, "strwhead", 0, 0, 0, 0 };
 152  153  struct qinit strdata = { strrput, NULL, NULL, NULL, NULL, &strm_info };
 153  154  struct qinit stwdata = { NULL, strwsrv, NULL, NULL, NULL, &stwm_info };
 154  155  struct module_info fiform_info = { 0, "fifostrrhead", 0, PIPE_BUF, FIFOHIWAT,
 155  156      FIFOLOWAT };
 156  157  struct module_info fifowm_info = { 0, "fifostrwhead", 0, 0, 0, 0 };
 157  158  struct qinit fifo_strdata = { strrput, NULL, NULL, NULL, NULL, &fiform_info };
 158  159  struct qinit fifo_stwdata = { NULL, strwsrv, NULL, NULL, NULL, &fifowm_info };
 159  160  
 160  161  extern kmutex_t strresources;   /* protects global resources */
 161  162  extern kmutex_t muxifier;       /* single-threads multiplexor creation */
 162  163  
 163  164  static boolean_t msghasdata(mblk_t *bp);
 164  165  #define msgnodata(bp) (!msghasdata(bp))
 165  166  
 166  167  /*
 167  168   * Stream head locking notes:
 168  169   *      There are four monitors associated with the stream head:
 169  170   *      1. v_stream monitor: in stropen() and strclose() v_lock
 170  171   *              is held while the association of vnode and stream
 171  172   *              head is established or tested for.
 172  173   *      2. open/close/push/pop monitor: sd_lock is held while each
 173  174   *              thread bids for exclusive access to this monitor
 174  175   *              for opening or closing a stream.  In addition, this
 175  176   *              monitor is entered during pushes and pops.  This
 176  177   *              guarantees that during plumbing operations there
 177  178   *              is only one thread trying to change the plumbing.
 178  179   *              Any other threads present in the stream are only
 179  180   *              using the plumbing.
 180  181   *      3. read/write monitor: in the case of read, a thread holds
 181  182   *              sd_lock while trying to get data from the stream
 182  183   *              head queue.  if there is none to fulfill a read
 183  184   *              request, it sets RSLEEP and calls cv_wait_sig() down
 184  185   *              in strwaitq() to await the arrival of new data.
 185  186   *              when new data arrives in strrput(), sd_lock is acquired
 186  187   *              before testing for RSLEEP and calling cv_broadcast().
 187  188   *              the behavior of strwrite(), strwsrv(), and WSLEEP
 188  189   *              mirror this.
 189  190   *      4. ioctl monitor: sd_lock is gotten to ensure that only one
 190  191   *              thread is doing an ioctl at a time.
 191  192   */
 192  193  
 193  194  static int
 194  195  push_mod(queue_t *qp, dev_t *devp, struct stdata *stp, const char *name,
 195  196      int anchor, cred_t *crp, uint_t anchor_zoneid)
 196  197  {
 197  198          int error;
 198  199          fmodsw_impl_t *fp;
 199  200  
 200  201          if (stp->sd_flag & (STRHUP|STRDERR|STWRERR)) {
 201  202                  error = (stp->sd_flag & STRHUP) ? ENXIO : EIO;
 202  203                  return (error);
 203  204          }
 204  205          if (stp->sd_pushcnt >= nstrpush) {
 205  206                  return (EINVAL);
 206  207          }
 207  208  
 208  209          if ((fp = fmodsw_find(name, FMODSW_HOLD | FMODSW_LOAD)) == NULL) {
 209  210                  stp->sd_flag |= STREOPENFAIL;
 210  211                  return (EINVAL);
 211  212          }
 212  213  
 213  214          /*
 214  215           * push new module and call its open routine via qattach
 215  216           */
 216  217          if ((error = qattach(qp, devp, 0, crp, fp, B_FALSE)) != 0)
 217  218                  return (error);
 218  219  
 219  220          /*
 220  221           * Check to see if caller wants a STREAMS anchor
 221  222           * put at this place in the stream, and add if so.
 222  223           */
 223  224          mutex_enter(&stp->sd_lock);
 224  225          if (anchor == stp->sd_pushcnt) {
 225  226                  stp->sd_anchor = stp->sd_pushcnt;
 226  227                  stp->sd_anchorzone = anchor_zoneid;
 227  228          }
 228  229          mutex_exit(&stp->sd_lock);
 229  230  
 230  231          return (0);
 231  232  }
 232  233  
 233  234  /*
 234  235   * Open a stream device.
 235  236   */
 236  237  int
 237  238  stropen(vnode_t *vp, dev_t *devp, int flag, cred_t *crp)
 238  239  {
 239  240          struct stdata *stp;
 240  241          queue_t *qp;
 241  242          int s;
 242  243          dev_t dummydev, savedev;
 243  244          struct autopush *ap;
 244  245          struct dlautopush dlap;
 245  246          int error = 0;
 246  247          ssize_t rmin, rmax;
 247  248          int cloneopen;
 248  249          queue_t *brq;
 249  250          major_t major;
 250  251          str_stack_t *ss;
 251  252          zoneid_t zoneid;
 252  253          uint_t anchor;
 253  254  
 254  255          /*
 255  256           * If the stream already exists, wait for any open in progress
 256  257           * to complete, then call the open function of each module and
 257  258           * driver in the stream.  Otherwise create the stream.
 258  259           */
 259  260          TRACE_1(TR_FAC_STREAMS_FR, TR_STROPEN, "stropen:%p", vp);
 260  261  retry:
 261  262          mutex_enter(&vp->v_lock);
 262  263          if ((stp = vp->v_stream) != NULL) {
 263  264  
 264  265                  /*
 265  266                   * Waiting for stream to be created to device
 266  267                   * due to another open.
 267  268                   */
 268  269                  mutex_exit(&vp->v_lock);
 269  270  
 270  271                  if (STRMATED(stp)) {
 271  272                          struct stdata *strmatep = stp->sd_mate;
 272  273  
 273  274                          STRLOCKMATES(stp);
 274  275                          if (strmatep->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {
 275  276                                  if (flag & (FNDELAY|FNONBLOCK)) {
 276  277                                          error = EAGAIN;
 277  278                                          mutex_exit(&strmatep->sd_lock);
 278  279                                          goto ckreturn;
 279  280                                  }
 280  281                                  mutex_exit(&stp->sd_lock);
 281  282                                  if (!cv_wait_sig(&strmatep->sd_monitor,
 282  283                                      &strmatep->sd_lock)) {
 283  284                                          error = EINTR;
 284  285                                          mutex_exit(&strmatep->sd_lock);
 285  286                                          mutex_enter(&stp->sd_lock);
 286  287                                          goto ckreturn;
 287  288                                  }
 288  289                                  mutex_exit(&strmatep->sd_lock);
 289  290                                  goto retry;
 290  291                          }
 291  292                          if (stp->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {
 292  293                                  if (flag & (FNDELAY|FNONBLOCK)) {
 293  294                                          error = EAGAIN;
 294  295                                          mutex_exit(&strmatep->sd_lock);
 295  296                                          goto ckreturn;
 296  297                                  }
 297  298                                  mutex_exit(&strmatep->sd_lock);
 298  299                                  if (!cv_wait_sig(&stp->sd_monitor,
 299  300                                      &stp->sd_lock)) {
 300  301                                          error = EINTR;
 301  302                                          goto ckreturn;
 302  303                                  }
 303  304                                  mutex_exit(&stp->sd_lock);
 304  305                                  goto retry;
 305  306                          }
 306  307  
 307  308                          if (stp->sd_flag & (STRDERR|STWRERR)) {
 308  309                                  error = EIO;
 309  310                                  mutex_exit(&strmatep->sd_lock);
 310  311                                  goto ckreturn;
 311  312                          }
 312  313  
 313  314                          stp->sd_flag |= STWOPEN;
 314  315                          STRUNLOCKMATES(stp);
 315  316                  } else {
 316  317                          mutex_enter(&stp->sd_lock);
 317  318                          if (stp->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {
 318  319                                  if (flag & (FNDELAY|FNONBLOCK)) {
 319  320                                          error = EAGAIN;
 320  321                                          goto ckreturn;
 321  322                                  }
 322  323                                  if (!cv_wait_sig(&stp->sd_monitor,
 323  324                                      &stp->sd_lock)) {
 324  325                                          error = EINTR;
 325  326                                          goto ckreturn;
 326  327                                  }
 327  328                                  mutex_exit(&stp->sd_lock);
 328  329                                  goto retry;  /* could be clone! */
 329  330                          }
 330  331  
 331  332                          if (stp->sd_flag & (STRDERR|STWRERR)) {
 332  333                                  error = EIO;
 333  334                                  goto ckreturn;
 334  335                          }
 335  336  
 336  337                          stp->sd_flag |= STWOPEN;
 337  338                          mutex_exit(&stp->sd_lock);
 338  339                  }
 339  340  
 340  341                  /*
 341  342                   * Open all modules and devices down stream to notify
 342  343                   * that another user is streaming.  For modules, set the
 343  344                   * last argument to MODOPEN and do not pass any open flags.
 344  345                   * Ignore dummydev since this is not the first open.
 345  346                   */
 346  347                  claimstr(stp->sd_wrq);
 347  348                  qp = stp->sd_wrq;
 348  349                  while (_SAMESTR(qp)) {
 349  350                          qp = qp->q_next;
 350  351                          if ((error = qreopen(_RD(qp), devp, flag, crp)) != 0)
 351  352                                  break;
 352  353                  }
 353  354                  releasestr(stp->sd_wrq);
 354  355                  mutex_enter(&stp->sd_lock);
 355  356                  stp->sd_flag &= ~(STRHUP|STWOPEN|STRDERR|STWRERR);
 356  357                  stp->sd_rerror = 0;
 357  358                  stp->sd_werror = 0;
 358  359  ckreturn:
 359  360                  cv_broadcast(&stp->sd_monitor);
 360  361                  mutex_exit(&stp->sd_lock);
 361  362                  return (error);
 362  363          }
 363  364  
 364  365          /*
 365  366           * This vnode isn't streaming.  SPECFS already
 366  367           * checked for multiple vnodes pointing to the
 367  368           * same stream, so create a stream to the driver.
 368  369           */
 369  370          qp = allocq();
 370  371          stp = shalloc(qp);
 371  372  
 372  373          /*
 373  374           * Initialize stream head.  shalloc() has given us
 374  375           * exclusive access, and we have the vnode locked;
 375  376           * we can do whatever we want with stp.
 376  377           */
 377  378          stp->sd_flag = STWOPEN;
 378  379          stp->sd_siglist = NULL;
 379  380          stp->sd_pollist.ph_list = NULL;
 380  381          stp->sd_sigflags = 0;
 381  382          stp->sd_mark = NULL;
 382  383          stp->sd_closetime = STRTIMOUT;
 383  384          stp->sd_sidp = NULL;
 384  385          stp->sd_pgidp = NULL;
 385  386          stp->sd_vnode = vp;
 386  387          stp->sd_rerror = 0;
 387  388          stp->sd_werror = 0;
 388  389          stp->sd_wroff = 0;
 389  390          stp->sd_tail = 0;
 390  391          stp->sd_iocblk = NULL;
 391  392          stp->sd_cmdblk = NULL;
 392  393          stp->sd_pushcnt = 0;
 393  394          stp->sd_qn_minpsz = 0;
 394  395          stp->sd_qn_maxpsz = INFPSZ - 1; /* used to check for initialization */
 395  396          stp->sd_maxblk = INFPSZ;
 396  397          qp->q_ptr = _WR(qp)->q_ptr = stp;
 397  398          STREAM(qp) = STREAM(_WR(qp)) = stp;
 398  399          vp->v_stream = stp;
 399  400          mutex_exit(&vp->v_lock);
 400  401          if (vp->v_type == VFIFO) {
 401  402                  stp->sd_flag |= OLDNDELAY;
 402  403                  /*
 403  404                   * This means, both for pipes and fifos
 404  405                   * strwrite will send SIGPIPE if the other
 405  406                   * end is closed. For putmsg it depends
 406  407                   * on whether it is a XPG4_2 application
 407  408                   * or not
 408  409                   */
 409  410                  stp->sd_wput_opt = SW_SIGPIPE;
 410  411  
 411  412                  /* setq might sleep in kmem_alloc - avoid holding locks. */
 412  413                  setq(qp, &fifo_strdata, &fifo_stwdata, NULL, QMTSAFE,
 413  414                      SQ_CI|SQ_CO, B_FALSE);
 414  415  
 415  416                  set_qend(qp);
 416  417                  stp->sd_strtab = fifo_getinfo();
 417  418                  _WR(qp)->q_nfsrv = _WR(qp);
 418  419                  qp->q_nfsrv = qp;
 419  420                  /*
 420  421                   * Wake up others that are waiting for stream to be created.
 421  422                   */
 422  423                  mutex_enter(&stp->sd_lock);
 423  424                  /*
 424  425                   * nothing is be pushed on stream yet, so
 425  426                   * optimized stream head packetsizes are just that
 426  427                   * of the read queue
 427  428                   */
 428  429                  stp->sd_qn_minpsz = qp->q_minpsz;
 429  430                  stp->sd_qn_maxpsz = qp->q_maxpsz;
 430  431                  stp->sd_flag &= ~STWOPEN;
 431  432                  goto fifo_opendone;
 432  433          }
 433  434          /* setq might sleep in kmem_alloc - avoid holding locks. */
 434  435          setq(qp, &strdata, &stwdata, NULL, QMTSAFE, SQ_CI|SQ_CO, B_FALSE);
 435  436  
 436  437          set_qend(qp);
 437  438  
 438  439          /*
 439  440           * Open driver and create stream to it (via qattach).
 440  441           */
 441  442          savedev = *devp;
 442  443          cloneopen = (getmajor(*devp) == clone_major);
 443  444          if ((error = qattach(qp, devp, flag, crp, NULL, B_FALSE)) != 0) {
 444  445                  mutex_enter(&vp->v_lock);
 445  446                  vp->v_stream = NULL;
 446  447                  mutex_exit(&vp->v_lock);
 447  448                  mutex_enter(&stp->sd_lock);
 448  449                  cv_broadcast(&stp->sd_monitor);
 449  450                  mutex_exit(&stp->sd_lock);
 450  451                  freeq(_RD(qp));
 451  452                  shfree(stp);
 452  453                  return (error);
 453  454          }
 454  455          /*
 455  456           * Set sd_strtab after open in order to handle clonable drivers
 456  457           */
 457  458          stp->sd_strtab = STREAMSTAB(getmajor(*devp));
 458  459  
 459  460          /*
 460  461           * Historical note: dummydev used to be be prior to the initial
 461  462           * open (via qattach above), which made the value seen
 462  463           * inconsistent between an I_PUSH and an autopush of a module.
 463  464           */
 464  465          dummydev = *devp;
 465  466  
 466  467          /*
 467  468           * For clone open of old style (Q not associated) network driver,
 468  469           * push DRMODNAME module to handle DL_ATTACH/DL_DETACH
 469  470           */
 470  471          brq = _RD(_WR(qp)->q_next);
 471  472          major = getmajor(*devp);
 472  473          if (push_drcompat && cloneopen && NETWORK_DRV(major) &&
 473  474              ((brq->q_flag & _QASSOCIATED) == 0)) {
 474  475                  if (push_mod(qp, &dummydev, stp, DRMODNAME, 0, crp, 0) != 0)
 475  476                          cmn_err(CE_WARN, "cannot push " DRMODNAME
 476  477                              " streams module");
 477  478          }
 478  479  
 479  480          if (!NETWORK_DRV(major)) {
 480  481                  savedev = *devp;
 481  482          } else {
 482  483                  /*
 483  484                   * For network devices, process differently based on the
 484  485                   * return value from dld_autopush():
 485  486                   *
 486  487                   *   0: the passed-in device points to a GLDv3 datalink with
 487  488                   *   per-link autopush configuration; use that configuration
 488  489                   *   and ignore any per-driver autopush configuration.
 489  490                   *
 490  491                   *   1: the passed-in device points to a physical GLDv3
 491  492                   *   datalink without per-link autopush configuration.  The
 492  493                   *   passed in device was changed to refer to the actual
 493  494                   *   physical device (if it's not already); we use that new
 494  495                   *   device to look up any per-driver autopush configuration.
 495  496                   *
 496  497                   *   -1: neither of the above cases applied; use the initial
 497  498                   *   device to look up any per-driver autopush configuration.
 498  499                   */
 499  500                  switch (dld_autopush(&savedev, &dlap)) {
 500  501                  case 0:
 501  502                          zoneid = crgetzoneid(crp);
 502  503                          for (s = 0; s < dlap.dap_npush; s++) {
 503  504                                  error = push_mod(qp, &dummydev, stp,
 504  505                                      dlap.dap_aplist[s], dlap.dap_anchor, crp,
 505  506                                      zoneid);
 506  507                                  if (error != 0)
 507  508                                          break;
 508  509                          }
 509  510                          goto opendone;
 510  511                  case 1:
 511  512                          break;
 512  513                  case -1:
 513  514                          savedev = *devp;
 514  515                          break;
 515  516                  }
 516  517          }
 517  518          /*
 518  519           * Find the autopush configuration based on "savedev". Start with the
 519  520           * global zone. If not found check in the local zone.
 520  521           */
 521  522          zoneid = GLOBAL_ZONEID;
 522  523  retryap:
 523  524          ss = netstack_find_by_stackid(zoneid_to_netstackid(zoneid))->
 524  525              netstack_str;
 525  526          if ((ap = sad_ap_find_by_dev(savedev, ss)) == NULL) {
 526  527                  netstack_rele(ss->ss_netstack);
 527  528                  if (zoneid == GLOBAL_ZONEID) {
 528  529                          /*
 529  530                           * None found. Also look in the zone's autopush table.
 530  531                           */
 531  532                          zoneid = crgetzoneid(crp);
 532  533                          if (zoneid != GLOBAL_ZONEID)
 533  534                                  goto retryap;
 534  535                  }
 535  536                  goto opendone;
 536  537          }
 537  538          anchor = ap->ap_anchor;
 538  539          zoneid = crgetzoneid(crp);
 539  540          for (s = 0; s < ap->ap_npush; s++) {
 540  541                  error = push_mod(qp, &dummydev, stp, ap->ap_list[s],
 541  542                      anchor, crp, zoneid);
 542  543                  if (error != 0)
 543  544                          break;
 544  545          }
 545  546          sad_ap_rele(ap, ss);
 546  547          netstack_rele(ss->ss_netstack);
 547  548  
 548  549  opendone:
 549  550  
 550  551          /*
 551  552           * let specfs know that open failed part way through
 552  553           */
 553  554          if (error) {
 554  555                  mutex_enter(&stp->sd_lock);
 555  556                  stp->sd_flag |= STREOPENFAIL;
 556  557                  mutex_exit(&stp->sd_lock);
 557  558          }
 558  559  
 559  560          /*
 560  561           * Wake up others that are waiting for stream to be created.
 561  562           */
 562  563          mutex_enter(&stp->sd_lock);
 563  564          stp->sd_flag &= ~STWOPEN;
 564  565  
 565  566          /*
 566  567           * As a performance concern we are caching the values of
 567  568           * q_minpsz and q_maxpsz of the module below the stream
 568  569           * head in the stream head.
 569  570           */
 570  571          mutex_enter(QLOCK(stp->sd_wrq->q_next));
 571  572          rmin = stp->sd_wrq->q_next->q_minpsz;
 572  573          rmax = stp->sd_wrq->q_next->q_maxpsz;
 573  574          mutex_exit(QLOCK(stp->sd_wrq->q_next));
 574  575  
 575  576          /* do this processing here as a performance concern */
 576  577          if (strmsgsz != 0) {
 577  578                  if (rmax == INFPSZ)
 578  579                          rmax = strmsgsz;
 579  580                  else
 580  581                          rmax = MIN(strmsgsz, rmax);
 581  582          }
 582  583  
 583  584          mutex_enter(QLOCK(stp->sd_wrq));
 584  585          stp->sd_qn_minpsz = rmin;
 585  586          stp->sd_qn_maxpsz = rmax;
 586  587          mutex_exit(QLOCK(stp->sd_wrq));
 587  588  
 588  589  fifo_opendone:
 589  590          cv_broadcast(&stp->sd_monitor);
 590  591          mutex_exit(&stp->sd_lock);
 591  592          return (error);
 592  593  }
 593  594  
 594  595  static int strsink(queue_t *, mblk_t *);
 595  596  static struct qinit deadrend = {
 596  597          strsink, NULL, NULL, NULL, NULL, &strm_info, NULL
 597  598  };
 598  599  static struct qinit deadwend = {
 599  600          NULL, NULL, NULL, NULL, NULL, &stwm_info, NULL
 600  601  };
 601  602  
 602  603  /*
 603  604   * Close a stream.
 604  605   * This is called from closef() on the last close of an open stream.
 605  606   * Strclean() will already have removed the siglist and pollist
 606  607   * information, so all that remains is to remove all multiplexor links
 607  608   * for the stream, pop all the modules (and the driver), and free the
 608  609   * stream structure.
 609  610   */
 610  611  
 611  612  int
 612  613  strclose(struct vnode *vp, int flag, cred_t *crp)
 613  614  {
 614  615          struct stdata *stp;
 615  616          queue_t *qp;
 616  617          int rval;
 617  618          int freestp = 1;
 618  619          queue_t *rmq;
 619  620  
 620  621          TRACE_1(TR_FAC_STREAMS_FR,
 621  622              TR_STRCLOSE, "strclose:%p", vp);
 622  623          ASSERT(vp->v_stream);
 623  624  
 624  625          stp = vp->v_stream;
 625  626          ASSERT(!(stp->sd_flag & STPLEX));
 626  627          qp = stp->sd_wrq;
 627  628  
 628  629          /*
 629  630           * Needed so that strpoll will return non-zero for this fd.
 630  631           * Note that with POLLNOERR STRHUP does still cause POLLHUP.
 631  632           */
 632  633          mutex_enter(&stp->sd_lock);
 633  634          stp->sd_flag |= STRHUP;
 634  635          mutex_exit(&stp->sd_lock);
 635  636  
 636  637          /*
 637  638           * If the registered process or process group did not have an
 638  639           * open instance of this stream then strclean would not be
 639  640           * called. Thus at the time of closing all remaining siglist entries
 640  641           * are removed.
 641  642           */
 642  643          if (stp->sd_siglist != NULL)
 643  644                  strcleanall(vp);
 644  645  
 645  646          ASSERT(stp->sd_siglist == NULL);
 646  647          ASSERT(stp->sd_sigflags == 0);
 647  648  
 648  649          if (STRMATED(stp)) {
 649  650                  struct stdata *strmatep = stp->sd_mate;
 650  651                  int waited = 1;
 651  652  
 652  653                  STRLOCKMATES(stp);
 653  654                  while (waited) {
 654  655                          waited = 0;
 655  656                          while (stp->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {
 656  657                                  mutex_exit(&strmatep->sd_lock);
 657  658                                  cv_wait(&stp->sd_monitor, &stp->sd_lock);
 658  659                                  mutex_exit(&stp->sd_lock);
 659  660                                  STRLOCKMATES(stp);
 660  661                                  waited = 1;
 661  662                          }
 662  663                          while (strmatep->sd_flag &
 663  664                              (STWOPEN|STRCLOSE|STRPLUMB)) {
 664  665                                  mutex_exit(&stp->sd_lock);
 665  666                                  cv_wait(&strmatep->sd_monitor,
 666  667                                      &strmatep->sd_lock);
 667  668                                  mutex_exit(&strmatep->sd_lock);
 668  669                                  STRLOCKMATES(stp);
 669  670                                  waited = 1;
 670  671                          }
 671  672                  }
 672  673                  stp->sd_flag |= STRCLOSE;
 673  674                  STRUNLOCKMATES(stp);
 674  675          } else {
 675  676                  mutex_enter(&stp->sd_lock);
 676  677                  stp->sd_flag |= STRCLOSE;
 677  678                  mutex_exit(&stp->sd_lock);
 678  679          }
 679  680  
 680  681          ASSERT(qp->q_first == NULL);    /* No more delayed write */
 681  682  
 682  683          /* Check if an I_LINK was ever done on this stream */
 683  684          if (stp->sd_flag & STRHASLINKS) {
 684  685                  netstack_t *ns;
 685  686                  str_stack_t *ss;
 686  687  
 687  688                  ns = netstack_find_by_cred(crp);
 688  689                  ASSERT(ns != NULL);
 689  690                  ss = ns->netstack_str;
 690  691                  ASSERT(ss != NULL);
 691  692  
 692  693                  (void) munlinkall(stp, LINKCLOSE|LINKNORMAL, crp, &rval, ss);
 693  694                  netstack_rele(ss->ss_netstack);
 694  695          }
 695  696  
 696  697          while (_SAMESTR(qp)) {
 697  698                  /*
 698  699                   * Holding sd_lock prevents q_next from changing in
 699  700                   * this stream.
 700  701                   */
 701  702                  mutex_enter(&stp->sd_lock);
 702  703                  if (!(flag & (FNDELAY|FNONBLOCK)) && (stp->sd_closetime > 0)) {
 703  704  
 704  705                          /*
 705  706                           * sleep until awakened by strwsrv() or timeout
 706  707                           */
 707  708                          for (;;) {
 708  709                                  mutex_enter(QLOCK(qp->q_next));
 709  710                                  if (!(qp->q_next->q_mblkcnt)) {
 710  711                                          mutex_exit(QLOCK(qp->q_next));
 711  712                                          break;
 712  713                                  }
 713  714                                  stp->sd_flag |= WSLEEP;
 714  715  
 715  716                                  /* ensure strwsrv gets enabled */
 716  717                                  qp->q_next->q_flag |= QWANTW;
 717  718                                  mutex_exit(QLOCK(qp->q_next));
 718  719                                  /* get out if we timed out or recv'd a signal */
 719  720                                  if (str_cv_wait(&qp->q_wait, &stp->sd_lock,
 720  721                                      stp->sd_closetime, 0) <= 0) {
 721  722                                          break;
 722  723                                  }
 723  724                          }
 724  725                          stp->sd_flag &= ~WSLEEP;
 725  726                  }
 726  727                  mutex_exit(&stp->sd_lock);
 727  728  
 728  729                  rmq = qp->q_next;
 729  730                  if (rmq->q_flag & QISDRV) {
 730  731                          ASSERT(!_SAMESTR(rmq));
 731  732                          wait_sq_svc(_RD(qp)->q_syncq);
 732  733                  }
 733  734  
 734  735                  qdetach(_RD(rmq), 1, flag, crp, B_FALSE);
 735  736          }
 736  737  
 737  738          /*
 738  739           * Since we call pollwakeup in close() now, the poll list should
 739  740           * be empty in most cases. The only exception is the layered devices
 740  741           * (e.g. the console drivers with redirection modules pushed on top
 741  742           * of it).  We have to do this after calling qdetach() because
 742  743           * the redirection module won't have torn down the console
 743  744           * redirection until after qdetach() has been invoked.
 744  745           */
 745  746          if (stp->sd_pollist.ph_list != NULL) {
 746  747                  pollwakeup(&stp->sd_pollist, POLLERR);
 747  748                  pollhead_clean(&stp->sd_pollist);
 748  749          }
 749  750          ASSERT(stp->sd_pollist.ph_list == NULL);
 750  751          ASSERT(stp->sd_sidp == NULL);
 751  752          ASSERT(stp->sd_pgidp == NULL);
 752  753  
 753  754          /* Prevent qenable from re-enabling the stream head queue */
 754  755          disable_svc(_RD(qp));
 755  756  
 756  757          /*
 757  758           * Wait until service procedure of each queue is
 758  759           * run, if QINSERVICE is set.
 759  760           */
 760  761          wait_svc(_RD(qp));
 761  762  
 762  763          /*
 763  764           * Now, flush both queues.
 764  765           */
 765  766          flushq(_RD(qp), FLUSHALL);
 766  767          flushq(qp, FLUSHALL);
 767  768  
 768  769          /*
 769  770           * If the write queue of the stream head is pointing to a
 770  771           * read queue, we have a twisted stream.  If the read queue
 771  772           * is alive, convert the stream head queues into a dead end.
 772  773           * If the read queue is dead, free the dead pair.
 773  774           */
 774  775          if (qp->q_next && !_SAMESTR(qp)) {
 775  776                  if (qp->q_next->q_qinfo == &deadrend) { /* half-closed pipe */
 776  777                          flushq(qp->q_next, FLUSHALL); /* ensure no message */
 777  778                          shfree(qp->q_next->q_stream);
 778  779                          freeq(qp->q_next);
 779  780                          freeq(_RD(qp));
 780  781                  } else if (qp->q_next == _RD(qp)) {     /* fifo */
 781  782                          freeq(_RD(qp));
 782  783                  } else {                                /* pipe */
 783  784                          freestp = 0;
 784  785                          /*
 785  786                           * The q_info pointers are never accessed when
 786  787                           * SQLOCK is held.
 787  788                           */
 788  789                          ASSERT(qp->q_syncq == _RD(qp)->q_syncq);
 789  790                          mutex_enter(SQLOCK(qp->q_syncq));
 790  791                          qp->q_qinfo = &deadwend;
 791  792                          _RD(qp)->q_qinfo = &deadrend;
 792  793                          mutex_exit(SQLOCK(qp->q_syncq));
 793  794                  }
 794  795          } else {
 795  796                  freeq(_RD(qp)); /* free stream head queue pair */
 796  797          }
 797  798  
 798  799          mutex_enter(&vp->v_lock);
 799  800          if (stp->sd_iocblk) {
 800  801                  if (stp->sd_iocblk != (mblk_t *)-1) {
 801  802                          freemsg(stp->sd_iocblk);
 802  803                  }
 803  804                  stp->sd_iocblk = NULL;
 804  805          }
 805  806          stp->sd_vnode = NULL;
 806  807          vp->v_stream = NULL;
 807  808          mutex_exit(&vp->v_lock);
 808  809          mutex_enter(&stp->sd_lock);
 809  810          freemsg(stp->sd_cmdblk);
 810  811          stp->sd_cmdblk = NULL;
 811  812          stp->sd_flag &= ~STRCLOSE;
 812  813          cv_broadcast(&stp->sd_monitor);
 813  814          mutex_exit(&stp->sd_lock);
 814  815  
 815  816          if (freestp)
 816  817                  shfree(stp);
 817  818          return (0);
 818  819  }
 819  820  
 820  821  static int
 821  822  strsink(queue_t *q, mblk_t *bp)
 822  823  {
 823  824          struct copyresp *resp;
 824  825  
 825  826          switch (bp->b_datap->db_type) {
 826  827          case M_FLUSH:
 827  828                  if ((*bp->b_rptr & FLUSHW) && !(bp->b_flag & MSGNOLOOP)) {
 828  829                          *bp->b_rptr &= ~FLUSHR;
 829  830                          bp->b_flag |= MSGNOLOOP;
 830  831                          /*
 831  832                           * Protect against the driver passing up
 832  833                           * messages after it has done a qprocsoff.
 833  834                           */
 834  835                          if (_OTHERQ(q)->q_next == NULL)
 835  836                                  freemsg(bp);
 836  837                          else
 837  838                                  qreply(q, bp);
 838  839                  } else {
 839  840                          freemsg(bp);
 840  841                  }
 841  842                  break;
 842  843  
 843  844          case M_COPYIN:
 844  845          case M_COPYOUT:
 845  846                  if (bp->b_cont) {
 846  847                          freemsg(bp->b_cont);
 847  848                          bp->b_cont = NULL;
 848  849                  }
 849  850                  bp->b_datap->db_type = M_IOCDATA;
 850  851                  bp->b_wptr = bp->b_rptr + sizeof (struct copyresp);
 851  852                  resp = (struct copyresp *)bp->b_rptr;
 852  853                  resp->cp_rval = (caddr_t)1;     /* failure */
 853  854                  /*
 854  855                   * Protect against the driver passing up
 855  856                   * messages after it has done a qprocsoff.
 856  857                   */
 857  858                  if (_OTHERQ(q)->q_next == NULL)
 858  859                          freemsg(bp);
 859  860                  else
 860  861                          qreply(q, bp);
 861  862                  break;
 862  863  
 863  864          case M_IOCTL:
 864  865                  if (bp->b_cont) {
 865  866                          freemsg(bp->b_cont);
 866  867                          bp->b_cont = NULL;
 867  868                  }
 868  869                  bp->b_datap->db_type = M_IOCNAK;
 869  870                  /*
 870  871                   * Protect against the driver passing up
 871  872                   * messages after it has done a qprocsoff.
 872  873                   */
 873  874                  if (_OTHERQ(q)->q_next == NULL)
 874  875                          freemsg(bp);
 875  876                  else
 876  877                          qreply(q, bp);
 877  878                  break;
 878  879  
 879  880          default:
 880  881                  freemsg(bp);
 881  882                  break;
 882  883          }
 883  884  
 884  885          return (0);
 885  886  }
 886  887  
 887  888  /*
 888  889   * Clean up after a process when it closes a stream.  This is called
 889  890   * from closef for all closes, whereas strclose is called only for the
 890  891   * last close on a stream.  The siglist is scanned for entries for the
 891  892   * current process, and these are removed.
 892  893   */
 893  894  void
 894  895  strclean(struct vnode *vp)
 895  896  {
 896  897          strsig_t *ssp, *pssp, *tssp;
 897  898          stdata_t *stp;
 898  899          int update = 0;
 899  900  
 900  901          TRACE_1(TR_FAC_STREAMS_FR,
 901  902              TR_STRCLEAN, "strclean:%p", vp);
 902  903          stp = vp->v_stream;
 903  904          pssp = NULL;
 904  905          mutex_enter(&stp->sd_lock);
 905  906          ssp = stp->sd_siglist;
 906  907          while (ssp) {
 907  908                  if (ssp->ss_pidp == curproc->p_pidp) {
 908  909                          tssp = ssp->ss_next;
 909  910                          if (pssp)
 910  911                                  pssp->ss_next = tssp;
 911  912                          else
 912  913                                  stp->sd_siglist = tssp;
 913  914                          mutex_enter(&pidlock);
 914  915                          PID_RELE(ssp->ss_pidp);
 915  916                          mutex_exit(&pidlock);
 916  917                          kmem_free(ssp, sizeof (strsig_t));
 917  918                          update = 1;
 918  919                          ssp = tssp;
 919  920                  } else {
 920  921                          pssp = ssp;
 921  922                          ssp = ssp->ss_next;
 922  923                  }
 923  924          }
 924  925          if (update) {
 925  926                  stp->sd_sigflags = 0;
 926  927                  for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
 927  928                          stp->sd_sigflags |= ssp->ss_events;
 928  929          }
 929  930          mutex_exit(&stp->sd_lock);
 930  931  }
 931  932  
 932  933  /*
 933  934   * Used on the last close to remove any remaining items on the siglist.
 934  935   * These could be present on the siglist due to I_ESETSIG calls that
 935  936   * use process groups or processed that do not have an open file descriptor
 936  937   * for this stream (Such entries would not be removed by strclean).
 937  938   */
 938  939  static void
 939  940  strcleanall(struct vnode *vp)
 940  941  {
 941  942          strsig_t *ssp, *nssp;
 942  943          stdata_t *stp;
 943  944  
 944  945          stp = vp->v_stream;
 945  946          mutex_enter(&stp->sd_lock);
 946  947          ssp = stp->sd_siglist;
 947  948          stp->sd_siglist = NULL;
 948  949          while (ssp) {
 949  950                  nssp = ssp->ss_next;
 950  951                  mutex_enter(&pidlock);
 951  952                  PID_RELE(ssp->ss_pidp);
 952  953                  mutex_exit(&pidlock);
 953  954                  kmem_free(ssp, sizeof (strsig_t));
 954  955                  ssp = nssp;
 955  956          }
 956  957          stp->sd_sigflags = 0;
 957  958          mutex_exit(&stp->sd_lock);
 958  959  }
 959  960  
 960  961  /*
 961  962   * Retrieve the next message from the logical stream head read queue
 962  963   * using either rwnext (if sync stream) or getq_noenab.
 963  964   * It is the callers responsibility to call qbackenable after
 964  965   * it is finished with the message. The caller should not call
 965  966   * qbackenable until after any putback calls to avoid spurious backenabling.
 966  967   */
 967  968  mblk_t *
 968  969  strget(struct stdata *stp, queue_t *q, struct uio *uiop, int first,
 969  970      int *errorp)
 970  971  {
 971  972          mblk_t *bp;
 972  973          int error;
 973  974          ssize_t rbytes = 0;
 974  975  
 975  976          /* Holding sd_lock prevents the read queue from changing  */
 976  977          ASSERT(MUTEX_HELD(&stp->sd_lock));
 977  978  
 978  979          if (uiop != NULL && stp->sd_struiordq != NULL &&
 979  980              q->q_first == NULL &&
 980  981              (!first || (stp->sd_wakeq & RSLEEP))) {
 981  982                  /*
 982  983                   * Stream supports rwnext() for the read side.
 983  984                   * If this is the first time we're called by e.g. strread
 984  985                   * only do the downcall if there is a deferred wakeup
 985  986                   * (registered in sd_wakeq).
 986  987                   */
 987  988                  struiod_t uiod;
 988  989  
 989  990                  if (first)
 990  991                          stp->sd_wakeq &= ~RSLEEP;
 991  992  
 992  993                  (void) uiodup(uiop, &uiod.d_uio, uiod.d_iov,
 993  994                      sizeof (uiod.d_iov) / sizeof (*uiod.d_iov));
 994  995                  uiod.d_mp = 0;
 995  996                  /*
 996  997                   * Mark that a thread is in rwnext on the read side
 997  998                   * to prevent strrput from nacking ioctls immediately.
 998  999                   * When the last concurrent rwnext returns
 999 1000                   * the ioctls are nack'ed.
1000 1001                   */
1001 1002                  ASSERT(MUTEX_HELD(&stp->sd_lock));
1002 1003                  stp->sd_struiodnak++;
1003 1004                  /*
1004 1005                   * Note: rwnext will drop sd_lock.
1005 1006                   */
1006 1007                  error = rwnext(q, &uiod);
1007 1008                  ASSERT(MUTEX_NOT_HELD(&stp->sd_lock));
1008 1009                  mutex_enter(&stp->sd_lock);
1009 1010                  stp->sd_struiodnak--;
1010 1011                  while (stp->sd_struiodnak == 0 &&
1011 1012                      ((bp = stp->sd_struionak) != NULL)) {
1012 1013                          stp->sd_struionak = bp->b_next;
1013 1014                          bp->b_next = NULL;
1014 1015                          bp->b_datap->db_type = M_IOCNAK;
1015 1016                          /*
1016 1017                           * Protect against the driver passing up
1017 1018                           * messages after it has done a qprocsoff.
1018 1019                           */
1019 1020                          if (_OTHERQ(q)->q_next == NULL)
1020 1021                                  freemsg(bp);
1021 1022                          else {
1022 1023                                  mutex_exit(&stp->sd_lock);
1023 1024                                  qreply(q, bp);
1024 1025                                  mutex_enter(&stp->sd_lock);
1025 1026                          }
1026 1027                  }
1027 1028                  ASSERT(MUTEX_HELD(&stp->sd_lock));
1028 1029                  if (error == 0 || error == EWOULDBLOCK) {
1029 1030                          if ((bp = uiod.d_mp) != NULL) {
1030 1031                                  *errorp = 0;
1031 1032                                  ASSERT(MUTEX_HELD(&stp->sd_lock));
1032 1033                                  return (bp);
1033 1034                          }
1034 1035                          error = 0;
1035 1036                  } else if (error == EINVAL) {
1036 1037                          /*
1037 1038                           * The stream plumbing must have
1038 1039                           * changed while we were away, so
1039 1040                           * just turn off rwnext()s.
1040 1041                           */
1041 1042                          error = 0;
1042 1043                  } else if (error == EBUSY) {
1043 1044                          /*
1044 1045                           * The module might have data in transit using putnext
1045 1046                           * Fall back on waiting + getq.
1046 1047                           */
1047 1048                          error = 0;
1048 1049                  } else {
1049 1050                          *errorp = error;
1050 1051                          ASSERT(MUTEX_HELD(&stp->sd_lock));
1051 1052                          return (NULL);
1052 1053                  }
1053 1054                  /*
1054 1055                   * Try a getq in case a rwnext() generated mblk
1055 1056                   * has bubbled up via strrput().
1056 1057                   */
1057 1058          }
1058 1059          *errorp = 0;
1059 1060          ASSERT(MUTEX_HELD(&stp->sd_lock));
1060 1061  
1061 1062          /*
1062 1063           * If we have a valid uio, try and use this as a guide for how
1063 1064           * many bytes to retrieve from the queue via getq_noenab().
1064 1065           * Doing this can avoid unneccesary counting of overlong
1065 1066           * messages in putback(). We currently only do this for sockets
1066 1067           * and only if there is no sd_rputdatafunc hook.
1067 1068           *
1068 1069           * The sd_rputdatafunc hook transforms the entire message
1069 1070           * before any bytes in it can be given to a client. So, rbytes
1070 1071           * must be 0 if there is a hook.
1071 1072           */
1072 1073          if ((uiop != NULL) && (stp->sd_vnode->v_type == VSOCK) &&
1073 1074              (stp->sd_rputdatafunc == NULL))
1074 1075                  rbytes = uiop->uio_resid;
1075 1076  
1076 1077          return (getq_noenab(q, rbytes));
1077 1078  }
1078 1079  
1079 1080  /*
1080 1081   * Copy out the message pointed to by `bp' into the uio pointed to by `uiop'.
1081 1082   * If the message does not fit in the uio the remainder of it is returned;
1082 1083   * otherwise NULL is returned.  Any embedded zero-length mblk_t's are
1083 1084   * consumed, even if uio_resid reaches zero.  On error, `*errorp' is set to
1084 1085   * the error code, the message is consumed, and NULL is returned.
1085 1086   */
1086 1087  static mblk_t *
1087 1088  struiocopyout(mblk_t *bp, struct uio *uiop, int *errorp)
1088 1089  {
1089 1090          int error;
1090 1091          ptrdiff_t n;
1091 1092          mblk_t *nbp;
1092 1093  
1093 1094          ASSERT(bp->b_wptr >= bp->b_rptr);
1094 1095  
1095 1096          do {
1096 1097                  if ((n = MIN(uiop->uio_resid, MBLKL(bp))) != 0) {
1097 1098                          ASSERT(n > 0);
1098 1099  
1099 1100                          error = uiomove(bp->b_rptr, n, UIO_READ, uiop);
1100 1101                          if (error != 0) {
1101 1102                                  freemsg(bp);
1102 1103                                  *errorp = error;
1103 1104                                  return (NULL);
1104 1105                          }
1105 1106                  }
1106 1107  
1107 1108                  bp->b_rptr += n;
1108 1109                  while (bp != NULL && (bp->b_rptr >= bp->b_wptr)) {
1109 1110                          nbp = bp;
1110 1111                          bp = bp->b_cont;
1111 1112                          freeb(nbp);
1112 1113                  }
1113 1114          } while (bp != NULL && uiop->uio_resid > 0);
1114 1115  
1115 1116          *errorp = 0;
1116 1117          return (bp);
1117 1118  }
1118 1119  
1119 1120  /*
1120 1121   * Read a stream according to the mode flags in sd_flag:
1121 1122   *
1122 1123   * (default mode)               - Byte stream, msg boundaries are ignored
1123 1124   * RD_MSGDIS (msg discard)      - Read on msg boundaries and throw away
1124 1125   *                              any data remaining in msg
1125 1126   * RD_MSGNODIS (msg non-discard) - Read on msg boundaries and put back
1126 1127   *                              any remaining data on head of read queue
1127 1128   *
1128 1129   * Consume readable messages on the front of the queue until
1129 1130   * ttolwp(curthread)->lwp_count
1130 1131   * is satisfied, the readable messages are exhausted, or a message
1131 1132   * boundary is reached in a message mode.  If no data was read and
1132 1133   * the stream was not opened with the NDELAY flag, block until data arrives.
1133 1134   * Otherwise return the data read and update the count.
1134 1135   *
1135 1136   * In default mode a 0 length message signifies end-of-file and terminates
1136 1137   * a read in progress.  The 0 length message is removed from the queue
1137 1138   * only if it is the only message read (no data is read).
1138 1139   *
1139 1140   * An attempt to read an M_PROTO or M_PCPROTO message results in an
1140 1141   * EBADMSG error return, unless either RD_PROTDAT or RD_PROTDIS are set.
1141 1142   * If RD_PROTDAT is set, M_PROTO and M_PCPROTO messages are read as data.
1142 1143   * If RD_PROTDIS is set, the M_PROTO and M_PCPROTO parts of the message
1143 1144   * are unlinked from and M_DATA blocks in the message, the protos are
1144 1145   * thrown away, and the data is read.
1145 1146   */
1146 1147  /* ARGSUSED */
1147 1148  int
1148 1149  strread(struct vnode *vp, struct uio *uiop, cred_t *crp)
1149 1150  {
1150 1151          struct stdata *stp;
1151 1152          mblk_t *bp, *nbp;
1152 1153          queue_t *q;
1153 1154          int error = 0;
1154 1155          uint_t old_sd_flag;
1155 1156          int first;
1156 1157          char rflg;
1157 1158          uint_t mark;            /* Contains MSG*MARK and _LASTMARK */
1158 1159  #define _LASTMARK       0x8000  /* Distinct from MSG*MARK */
1159 1160          short delim;
1160 1161          unsigned char pri = 0;
1161 1162          char waitflag;
1162 1163          unsigned char type;
1163 1164  
1164 1165          TRACE_1(TR_FAC_STREAMS_FR,
1165 1166              TR_STRREAD_ENTER, "strread:%p", vp);
1166 1167          ASSERT(vp->v_stream);
1167 1168          stp = vp->v_stream;
1168 1169  
1169 1170          mutex_enter(&stp->sd_lock);
1170 1171  
1171 1172          if ((error = i_straccess(stp, JCREAD)) != 0) {
1172 1173                  mutex_exit(&stp->sd_lock);
1173 1174                  return (error);
1174 1175          }
1175 1176  
1176 1177          if (stp->sd_flag & (STRDERR|STPLEX)) {
1177 1178                  error = strgeterr(stp, STRDERR|STPLEX, 0);
1178 1179                  if (error != 0) {
1179 1180                          mutex_exit(&stp->sd_lock);
1180 1181                          return (error);
1181 1182                  }
1182 1183          }
1183 1184  
1184 1185          /*
1185 1186           * Loop terminates when uiop->uio_resid == 0.
1186 1187           */
1187 1188          rflg = 0;
1188 1189          waitflag = READWAIT;
1189 1190          q = _RD(stp->sd_wrq);
1190 1191          for (;;) {
1191 1192                  ASSERT(MUTEX_HELD(&stp->sd_lock));
1192 1193                  old_sd_flag = stp->sd_flag;
1193 1194                  mark = 0;
1194 1195                  delim = 0;
1195 1196                  first = 1;
1196 1197                  while ((bp = strget(stp, q, uiop, first, &error)) == NULL) {
1197 1198                          int done = 0;
1198 1199  
1199 1200                          ASSERT(MUTEX_HELD(&stp->sd_lock));
1200 1201  
1201 1202                          if (error != 0)
1202 1203                                  goto oops;
1203 1204  
1204 1205                          if (stp->sd_flag & (STRHUP|STREOF)) {
1205 1206                                  goto oops;
1206 1207                          }
1207 1208                          if (rflg && !(stp->sd_flag & STRDELIM)) {
1208 1209                                  goto oops;
1209 1210                          }
1210 1211                          /*
1211 1212                           * If a read(fd,buf,0) has been done, there is no
1212 1213                           * need to sleep. We always have zero bytes to
1213 1214                           * return.
1214 1215                           */
1215 1216                          if (uiop->uio_resid == 0) {
1216 1217                                  goto oops;
1217 1218                          }
1218 1219  
1219 1220                          qbackenable(q, 0);
1220 1221  
1221 1222                          TRACE_3(TR_FAC_STREAMS_FR, TR_STRREAD_WAIT,
1222 1223                              "strread calls strwaitq:%p, %p, %p",
1223 1224                              vp, uiop, crp);
1224 1225                          if ((error = strwaitq(stp, waitflag, uiop->uio_resid,
1225 1226                              uiop->uio_fmode, -1, &done)) != 0 || done) {
1226 1227                                  TRACE_3(TR_FAC_STREAMS_FR, TR_STRREAD_DONE,
1227 1228                                      "strread error or done:%p, %p, %p",
1228 1229                                      vp, uiop, crp);
1229 1230                                  if ((uiop->uio_fmode & FNDELAY) &&
1230 1231                                      (stp->sd_flag & OLDNDELAY) &&
1231 1232                                      (error == EAGAIN))
1232 1233                                          error = 0;
1233 1234                                  goto oops;
1234 1235                          }
1235 1236                          TRACE_3(TR_FAC_STREAMS_FR, TR_STRREAD_AWAKE,
1236 1237                              "strread awakes:%p, %p, %p", vp, uiop, crp);
1237 1238                          if ((error = i_straccess(stp, JCREAD)) != 0) {
1238 1239                                  goto oops;
1239 1240                          }
1240 1241                          first = 0;
1241 1242                  }
1242 1243  
1243 1244                  ASSERT(MUTEX_HELD(&stp->sd_lock));
1244 1245                  ASSERT(bp);
1245 1246                  pri = bp->b_band;
1246 1247                  /*
1247 1248                   * Extract any mark information. If the message is not
1248 1249                   * completely consumed this information will be put in the mblk
1249 1250                   * that is putback.
1250 1251                   * If MSGMARKNEXT is set and the message is completely consumed
1251 1252                   * the STRATMARK flag will be set below. Likewise, if
1252 1253                   * MSGNOTMARKNEXT is set and the message is
1253 1254                   * completely consumed STRNOTATMARK will be set.
1254 1255                   *
1255 1256                   * For some unknown reason strread only breaks the read at the
1256 1257                   * last mark.
1257 1258                   */
1258 1259                  mark = bp->b_flag & (MSGMARK | MSGMARKNEXT | MSGNOTMARKNEXT);
1259 1260                  ASSERT((mark & (MSGMARKNEXT|MSGNOTMARKNEXT)) !=
1260 1261                      (MSGMARKNEXT|MSGNOTMARKNEXT));
1261 1262                  if (mark != 0 && bp == stp->sd_mark) {
1262 1263                          if (rflg) {
1263 1264                                  putback(stp, q, bp, pri);
1264 1265                                  goto oops;
1265 1266                          }
1266 1267                          mark |= _LASTMARK;
1267 1268                          stp->sd_mark = NULL;
1268 1269                  }
1269 1270                  if ((stp->sd_flag & STRDELIM) && (bp->b_flag & MSGDELIM))
1270 1271                          delim = 1;
1271 1272                  mutex_exit(&stp->sd_lock);
1272 1273  
1273 1274                  if (STREAM_NEEDSERVICE(stp))
1274 1275                          stream_runservice(stp);
1275 1276  
1276 1277                  type = bp->b_datap->db_type;
1277 1278  
1278 1279                  switch (type) {
1279 1280  
1280 1281                  case M_DATA:
1281 1282  ismdata:
1282 1283                          if (msgnodata(bp)) {
1283 1284                                  if (mark || delim) {
1284 1285                                          freemsg(bp);
1285 1286                                  } else if (rflg) {
1286 1287  
1287 1288                                          /*
1288 1289                                           * If already read data put zero
1289 1290                                           * length message back on queue else
1290 1291                                           * free msg and return 0.
1291 1292                                           */
1292 1293                                          bp->b_band = pri;
1293 1294                                          mutex_enter(&stp->sd_lock);
1294 1295                                          putback(stp, q, bp, pri);
1295 1296                                          mutex_exit(&stp->sd_lock);
1296 1297                                  } else {
1297 1298                                          freemsg(bp);
1298 1299                                  }
1299 1300                                  error =  0;
1300 1301                                  goto oops1;
1301 1302                          }
1302 1303  
1303 1304                          rflg = 1;
1304 1305                          waitflag |= NOINTR;
1305 1306                          bp = struiocopyout(bp, uiop, &error);
1306 1307                          if (error != 0)
1307 1308                                  goto oops1;
1308 1309  
1309 1310                          mutex_enter(&stp->sd_lock);
1310 1311                          if (bp) {
1311 1312                                  /*
1312 1313                                   * Have remaining data in message.
1313 1314                                   * Free msg if in discard mode.
1314 1315                                   */
1315 1316                                  if (stp->sd_read_opt & RD_MSGDIS) {
1316 1317                                          freemsg(bp);
1317 1318                                  } else {
1318 1319                                          bp->b_band = pri;
1319 1320                                          if ((mark & _LASTMARK) &&
1320 1321                                              (stp->sd_mark == NULL))
1321 1322                                                  stp->sd_mark = bp;
1322 1323                                          bp->b_flag |= mark & ~_LASTMARK;
1323 1324                                          if (delim)
1324 1325                                                  bp->b_flag |= MSGDELIM;
1325 1326                                          if (msgnodata(bp))
1326 1327                                                  freemsg(bp);
1327 1328                                          else
1328 1329                                                  putback(stp, q, bp, pri);
1329 1330                                  }
1330 1331                          } else {
1331 1332                                  /*
1332 1333                                   * Consumed the complete message.
1333 1334                                   * Move the MSG*MARKNEXT information
1334 1335                                   * to the stream head just in case
1335 1336                                   * the read queue becomes empty.
1336 1337                                   *
1337 1338                                   * If the stream head was at the mark
1338 1339                                   * (STRATMARK) before we dropped sd_lock above
1339 1340                                   * and some data was consumed then we have
1340 1341                                   * moved past the mark thus STRATMARK is
1341 1342                                   * cleared. However, if a message arrived in
1342 1343                                   * strrput during the copyout above causing
1343 1344                                   * STRATMARK to be set we can not clear that
1344 1345                                   * flag.
1345 1346                                   */
1346 1347                                  if (mark &
1347 1348                                      (MSGMARKNEXT|MSGNOTMARKNEXT|MSGMARK)) {
1348 1349                                          if (mark & MSGMARKNEXT) {
1349 1350                                                  stp->sd_flag &= ~STRNOTATMARK;
1350 1351                                                  stp->sd_flag |= STRATMARK;
1351 1352                                          } else if (mark & MSGNOTMARKNEXT) {
1352 1353                                                  stp->sd_flag &= ~STRATMARK;
1353 1354                                                  stp->sd_flag |= STRNOTATMARK;
1354 1355                                          } else {
1355 1356                                                  stp->sd_flag &=
1356 1357                                                      ~(STRATMARK|STRNOTATMARK);
1357 1358                                          }
1358 1359                                  } else if (rflg && (old_sd_flag & STRATMARK)) {
1359 1360                                          stp->sd_flag &= ~STRATMARK;
1360 1361                                  }
1361 1362                          }
1362 1363  
1363 1364                          /*
1364 1365                           * Check for signal messages at the front of the read
1365 1366                           * queue and generate the signal(s) if appropriate.
1366 1367                           * The only signal that can be on queue is M_SIG at
1367 1368                           * this point.
1368 1369                           */
1369 1370                          while ((((bp = q->q_first)) != NULL) &&
1370 1371                              (bp->b_datap->db_type == M_SIG)) {
1371 1372                                  bp = getq_noenab(q, 0);
1372 1373                                  /*
1373 1374                                   * sd_lock is held so the content of the
1374 1375                                   * read queue can not change.
1375 1376                                   */
1376 1377                                  ASSERT(bp != NULL && DB_TYPE(bp) == M_SIG);
1377 1378                                  strsignal_nolock(stp, *bp->b_rptr, bp->b_band);
1378 1379                                  mutex_exit(&stp->sd_lock);
1379 1380                                  freemsg(bp);
1380 1381                                  if (STREAM_NEEDSERVICE(stp))
1381 1382                                          stream_runservice(stp);
1382 1383                                  mutex_enter(&stp->sd_lock);
1383 1384                          }
1384 1385  
1385 1386                          if ((uiop->uio_resid == 0) || (mark & _LASTMARK) ||
1386 1387                              delim ||
1387 1388                              (stp->sd_read_opt & (RD_MSGDIS|RD_MSGNODIS))) {
1388 1389                                  goto oops;
1389 1390                          }
1390 1391                          continue;
1391 1392  
1392 1393                  case M_SIG:
1393 1394                          strsignal(stp, *bp->b_rptr, (int32_t)bp->b_band);
1394 1395                          freemsg(bp);
1395 1396                          mutex_enter(&stp->sd_lock);
1396 1397                          continue;
1397 1398  
1398 1399                  case M_PROTO:
1399 1400                  case M_PCPROTO:
1400 1401                          /*
1401 1402                           * Only data messages are readable.
1402 1403                           * Any others generate an error, unless
1403 1404                           * RD_PROTDIS or RD_PROTDAT is set.
1404 1405                           */
1405 1406                          if (stp->sd_read_opt & RD_PROTDAT) {
1406 1407                                  for (nbp = bp; nbp; nbp = nbp->b_next) {
1407 1408                                          if ((nbp->b_datap->db_type ==
1408 1409                                              M_PROTO) ||
1409 1410                                              (nbp->b_datap->db_type ==
1410 1411                                              M_PCPROTO)) {
1411 1412                                                  nbp->b_datap->db_type = M_DATA;
1412 1413                                          } else {
1413 1414                                                  break;
1414 1415                                          }
1415 1416                                  }
1416 1417                                  /*
1417 1418                                   * clear stream head hi pri flag based on
1418 1419                                   * first message
1419 1420                                   */
1420 1421                                  if (type == M_PCPROTO) {
1421 1422                                          mutex_enter(&stp->sd_lock);
1422 1423                                          stp->sd_flag &= ~STRPRI;
1423 1424                                          mutex_exit(&stp->sd_lock);
1424 1425                                  }
1425 1426                                  goto ismdata;
1426 1427                          } else if (stp->sd_read_opt & RD_PROTDIS) {
1427 1428                                  /*
1428 1429                                   * discard non-data messages
1429 1430                                   */
1430 1431                                  while (bp &&
1431 1432                                      ((bp->b_datap->db_type == M_PROTO) ||
1432 1433                                      (bp->b_datap->db_type == M_PCPROTO))) {
1433 1434                                          nbp = unlinkb(bp);
1434 1435                                          freeb(bp);
1435 1436                                          bp = nbp;
1436 1437                                  }
1437 1438                                  /*
1438 1439                                   * clear stream head hi pri flag based on
1439 1440                                   * first message
1440 1441                                   */
1441 1442                                  if (type == M_PCPROTO) {
1442 1443                                          mutex_enter(&stp->sd_lock);
1443 1444                                          stp->sd_flag &= ~STRPRI;
1444 1445                                          mutex_exit(&stp->sd_lock);
1445 1446                                  }
1446 1447                                  if (bp) {
1447 1448                                          bp->b_band = pri;
1448 1449                                          goto ismdata;
1449 1450                                  } else {
1450 1451                                          break;
1451 1452                                  }
1452 1453                          }
1453 1454                          /* FALLTHRU */
1454 1455                  case M_PASSFP:
1455 1456                          if ((bp->b_datap->db_type == M_PASSFP) &&
1456 1457                              (stp->sd_read_opt & RD_PROTDIS)) {
1457 1458                                  freemsg(bp);
1458 1459                                  break;
1459 1460                          }
1460 1461                          mutex_enter(&stp->sd_lock);
1461 1462                          putback(stp, q, bp, pri);
1462 1463                          mutex_exit(&stp->sd_lock);
1463 1464                          if (rflg == 0)
1464 1465                                  error = EBADMSG;
1465 1466                          goto oops1;
1466 1467  
1467 1468                  default:
1468 1469                          /*
1469 1470                           * Garbage on stream head read queue.
1470 1471                           */
1471 1472                          cmn_err(CE_WARN, "bad %x found at stream head\n",
1472 1473                              bp->b_datap->db_type);
1473 1474                          freemsg(bp);
1474 1475                          goto oops1;
1475 1476                  }
1476 1477                  mutex_enter(&stp->sd_lock);
1477 1478          }
1478 1479  oops:
1479 1480          mutex_exit(&stp->sd_lock);
1480 1481  oops1:
1481 1482          qbackenable(q, pri);
1482 1483          return (error);
1483 1484  #undef  _LASTMARK
1484 1485  }
1485 1486  
1486 1487  /*
1487 1488   * Default processing of M_PROTO/M_PCPROTO messages.
1488 1489   * Determine which wakeups and signals are needed.
1489 1490   * This can be replaced by a user-specified procedure for kernel users
1490 1491   * of STREAMS.
1491 1492   */
1492 1493  /* ARGSUSED */
1493 1494  mblk_t *
1494 1495  strrput_proto(vnode_t *vp, mblk_t *mp,
1495 1496      strwakeup_t *wakeups, strsigset_t *firstmsgsigs,
1496 1497      strsigset_t *allmsgsigs, strpollset_t *pollwakeups)
1497 1498  {
1498 1499          *wakeups = RSLEEP;
1499 1500          *allmsgsigs = 0;
1500 1501  
1501 1502          switch (mp->b_datap->db_type) {
1502 1503          case M_PROTO:
1503 1504                  if (mp->b_band == 0) {
1504 1505                          *firstmsgsigs = S_INPUT | S_RDNORM;
1505 1506                          *pollwakeups = POLLIN | POLLRDNORM;
1506 1507                  } else {
1507 1508                          *firstmsgsigs = S_INPUT | S_RDBAND;
1508 1509                          *pollwakeups = POLLIN | POLLRDBAND;
1509 1510                  }
1510 1511                  break;
1511 1512          case M_PCPROTO:
1512 1513                  *firstmsgsigs = S_HIPRI;
1513 1514                  *pollwakeups = POLLPRI;
1514 1515                  break;
1515 1516          }
1516 1517          return (mp);
1517 1518  }
1518 1519  
1519 1520  /*
1520 1521   * Default processing of everything but M_DATA, M_PROTO, M_PCPROTO and
1521 1522   * M_PASSFP messages.
1522 1523   * Determine which wakeups and signals are needed.
1523 1524   * This can be replaced by a user-specified procedure for kernel users
1524 1525   * of STREAMS.
1525 1526   */
1526 1527  /* ARGSUSED */
1527 1528  mblk_t *
1528 1529  strrput_misc(vnode_t *vp, mblk_t *mp,
1529 1530      strwakeup_t *wakeups, strsigset_t *firstmsgsigs,
1530 1531      strsigset_t *allmsgsigs, strpollset_t *pollwakeups)
1531 1532  {
1532 1533          *wakeups = 0;
1533 1534          *firstmsgsigs = 0;
1534 1535          *allmsgsigs = 0;
1535 1536          *pollwakeups = 0;
1536 1537          return (mp);
1537 1538  }
1538 1539  
1539 1540  /*
1540 1541   * Stream read put procedure.  Called from downstream driver/module
1541 1542   * with messages for the stream head.  Data, protocol, and in-stream
1542 1543   * signal messages are placed on the queue, others are handled directly.
1543 1544   */
1544 1545  int
1545 1546  strrput(queue_t *q, mblk_t *bp)
1546 1547  {
1547 1548          struct stdata   *stp;
1548 1549          ulong_t         rput_opt;
1549 1550          strwakeup_t     wakeups;
1550 1551          strsigset_t     firstmsgsigs;   /* Signals if first message on queue */
1551 1552          strsigset_t     allmsgsigs;     /* Signals for all messages */
1552 1553          strsigset_t     signals;        /* Signals events to generate */
1553 1554          strpollset_t    pollwakeups;
1554 1555          mblk_t          *nextbp;
1555 1556          uchar_t         band = 0;
1556 1557          int             hipri_sig;
1557 1558  
1558 1559          stp = (struct stdata *)q->q_ptr;
1559 1560          /*
1560 1561           * Use rput_opt for optimized access to the SR_ flags except
1561 1562           * SR_POLLIN. That flag has to be checked under sd_lock since it
1562 1563           * is modified by strpoll().
1563 1564           */
1564 1565          rput_opt = stp->sd_rput_opt;
1565 1566  
1566 1567          ASSERT(qclaimed(q));
1567 1568          TRACE_2(TR_FAC_STREAMS_FR, TR_STRRPUT_ENTER,
1568 1569              "strrput called with message type:q %p bp %p", q, bp);
1569 1570  
1570 1571          /*
1571 1572           * Perform initial processing and pass to the parameterized functions.
1572 1573           */
1573 1574          ASSERT(bp->b_next == NULL);
1574 1575  
1575 1576          switch (bp->b_datap->db_type) {
1576 1577          case M_DATA:
1577 1578                  /*
1578 1579                   * sockfs is the only consumer of STREOF and when it is set,
1579 1580                   * it implies that the receiver is not interested in receiving
1580 1581                   * any more data, hence the mblk is freed to prevent unnecessary
1581 1582                   * message queueing at the stream head.
1582 1583                   */
1583 1584                  if (stp->sd_flag == STREOF) {
1584 1585                          freemsg(bp);
1585 1586                          return (0);
1586 1587                  }
1587 1588                  if ((rput_opt & SR_IGN_ZEROLEN) &&
1588 1589                      bp->b_rptr == bp->b_wptr && msgnodata(bp)) {
1589 1590                          /*
1590 1591                           * Ignore zero-length M_DATA messages. These might be
1591 1592                           * generated by some transports.
1592 1593                           * The zero-length M_DATA messages, even if they
1593 1594                           * are ignored, should effect the atmark tracking and
1594 1595                           * should wake up a thread sleeping in strwaitmark.
1595 1596                           */
1596 1597                          mutex_enter(&stp->sd_lock);
1597 1598                          if (bp->b_flag & MSGMARKNEXT) {
1598 1599                                  /*
1599 1600                                   * Record the position of the mark either
1600 1601                                   * in q_last or in STRATMARK.
1601 1602                                   */
1602 1603                                  if (q->q_last != NULL) {
1603 1604                                          q->q_last->b_flag &= ~MSGNOTMARKNEXT;
1604 1605                                          q->q_last->b_flag |= MSGMARKNEXT;
1605 1606                                  } else {
1606 1607                                          stp->sd_flag &= ~STRNOTATMARK;
1607 1608                                          stp->sd_flag |= STRATMARK;
1608 1609                                  }
1609 1610                          } else if (bp->b_flag & MSGNOTMARKNEXT) {
1610 1611                                  /*
1611 1612                                   * Record that this is not the position of
1612 1613                                   * the mark either in q_last or in
1613 1614                                   * STRNOTATMARK.
1614 1615                                   */
1615 1616                                  if (q->q_last != NULL) {
1616 1617                                          q->q_last->b_flag &= ~MSGMARKNEXT;
1617 1618                                          q->q_last->b_flag |= MSGNOTMARKNEXT;
1618 1619                                  } else {
1619 1620                                          stp->sd_flag &= ~STRATMARK;
1620 1621                                          stp->sd_flag |= STRNOTATMARK;
1621 1622                                  }
1622 1623                          }
1623 1624                          if (stp->sd_flag & RSLEEP) {
1624 1625                                  stp->sd_flag &= ~RSLEEP;
1625 1626                                  cv_broadcast(&q->q_wait);
1626 1627                          }
1627 1628                          mutex_exit(&stp->sd_lock);
1628 1629                          freemsg(bp);
1629 1630                          return (0);
1630 1631                  }
1631 1632                  wakeups = RSLEEP;
1632 1633                  if (bp->b_band == 0) {
1633 1634                          firstmsgsigs = S_INPUT | S_RDNORM;
1634 1635                          pollwakeups = POLLIN | POLLRDNORM;
1635 1636                  } else {
1636 1637                          firstmsgsigs = S_INPUT | S_RDBAND;
1637 1638                          pollwakeups = POLLIN | POLLRDBAND;
1638 1639                  }
1639 1640                  if (rput_opt & SR_SIGALLDATA)
1640 1641                          allmsgsigs = firstmsgsigs;
1641 1642                  else
1642 1643                          allmsgsigs = 0;
1643 1644  
1644 1645                  mutex_enter(&stp->sd_lock);
1645 1646                  if ((rput_opt & SR_CONSOL_DATA) &&
1646 1647                      (q->q_last != NULL) &&
1647 1648                      (bp->b_flag & (MSGMARK|MSGDELIM)) == 0) {
1648 1649                          /*
1649 1650                           * Consolidate an M_DATA message onto an M_DATA,
1650 1651                           * M_PROTO, or M_PCPROTO by merging it with q_last.
1651 1652                           * The consolidation does not take place if
1652 1653                           * the old message is marked with either of the
1653 1654                           * marks or the delim flag or if the new
1654 1655                           * message is marked with MSGMARK. The MSGMARK
1655 1656                           * check is needed to handle the odd semantics of
1656 1657                           * MSGMARK where essentially the whole message
1657 1658                           * is to be treated as marked.
1658 1659                           * Carry any MSGMARKNEXT  and MSGNOTMARKNEXT from the
1659 1660                           * new message to the front of the b_cont chain.
1660 1661                           */
1661 1662                          mblk_t *lbp = q->q_last;
1662 1663                          unsigned char db_type = lbp->b_datap->db_type;
1663 1664  
1664 1665                          if ((db_type == M_DATA || db_type == M_PROTO ||
1665 1666                              db_type == M_PCPROTO) &&
1666 1667                              !(lbp->b_flag & (MSGDELIM|MSGMARK|MSGMARKNEXT))) {
1667 1668                                  rmvq_noenab(q, lbp);
1668 1669                                  /*
1669 1670                                   * The first message in the b_cont list
1670 1671                                   * tracks MSGMARKNEXT and MSGNOTMARKNEXT.
1671 1672                                   * We need to handle the case where we
1672 1673                                   * are appending:
1673 1674                                   *
1674 1675                                   * 1) a MSGMARKNEXT to a MSGNOTMARKNEXT.
1675 1676                                   * 2) a MSGMARKNEXT to a plain message.
1676 1677                                   * 3) a MSGNOTMARKNEXT to a plain message
1677 1678                                   * 4) a MSGNOTMARKNEXT to a MSGNOTMARKNEXT
1678 1679                                   *    message.
1679 1680                                   *
1680 1681                                   * Thus we never append a MSGMARKNEXT or
1681 1682                                   * MSGNOTMARKNEXT to a MSGMARKNEXT message.
1682 1683                                   */
1683 1684                                  if (bp->b_flag & MSGMARKNEXT) {
1684 1685                                          lbp->b_flag |= MSGMARKNEXT;
1685 1686                                          lbp->b_flag &= ~MSGNOTMARKNEXT;
1686 1687                                          bp->b_flag &= ~MSGMARKNEXT;
1687 1688                                  } else if (bp->b_flag & MSGNOTMARKNEXT) {
1688 1689                                          lbp->b_flag |= MSGNOTMARKNEXT;
1689 1690                                          bp->b_flag &= ~MSGNOTMARKNEXT;
1690 1691                                  }
1691 1692  
1692 1693                                  linkb(lbp, bp);
1693 1694                                  bp = lbp;
1694 1695                                  /*
1695 1696                                   * The new message logically isn't the first
1696 1697                                   * even though the q_first check below thinks
1697 1698                                   * it is. Clear the firstmsgsigs to make it
1698 1699                                   * not appear to be first.
1699 1700                                   */
1700 1701                                  firstmsgsigs = 0;
1701 1702                          }
1702 1703                  }
1703 1704                  break;
1704 1705  
1705 1706          case M_PASSFP:
1706 1707                  wakeups = RSLEEP;
1707 1708                  allmsgsigs = 0;
1708 1709                  if (bp->b_band == 0) {
1709 1710                          firstmsgsigs = S_INPUT | S_RDNORM;
1710 1711                          pollwakeups = POLLIN | POLLRDNORM;
1711 1712                  } else {
1712 1713                          firstmsgsigs = S_INPUT | S_RDBAND;
1713 1714                          pollwakeups = POLLIN | POLLRDBAND;
1714 1715                  }
1715 1716                  mutex_enter(&stp->sd_lock);
1716 1717                  break;
1717 1718  
1718 1719          case M_PROTO:
1719 1720          case M_PCPROTO:
1720 1721                  ASSERT(stp->sd_rprotofunc != NULL);
1721 1722                  bp = (stp->sd_rprotofunc)(stp->sd_vnode, bp,
1722 1723                      &wakeups, &firstmsgsigs, &allmsgsigs, &pollwakeups);
1723 1724  #define ALLSIG  (S_INPUT|S_HIPRI|S_OUTPUT|S_MSG|S_ERROR|S_HANGUP|S_RDNORM|\
1724 1725                  S_WRNORM|S_RDBAND|S_WRBAND|S_BANDURG)
1725 1726  #define ALLPOLL (POLLIN|POLLPRI|POLLOUT|POLLRDNORM|POLLWRNORM|POLLRDBAND|\
1726 1727                  POLLWRBAND)
1727 1728  
1728 1729                  ASSERT((wakeups & ~(RSLEEP|WSLEEP)) == 0);
1729 1730                  ASSERT((firstmsgsigs & ~ALLSIG) == 0);
1730 1731                  ASSERT((allmsgsigs & ~ALLSIG) == 0);
1731 1732                  ASSERT((pollwakeups & ~ALLPOLL) == 0);
1732 1733  
1733 1734                  mutex_enter(&stp->sd_lock);
1734 1735                  break;
1735 1736  
1736 1737          default:
1737 1738                  ASSERT(stp->sd_rmiscfunc != NULL);
1738 1739                  bp = (stp->sd_rmiscfunc)(stp->sd_vnode, bp,
1739 1740                      &wakeups, &firstmsgsigs, &allmsgsigs, &pollwakeups);
1740 1741                  ASSERT((wakeups & ~(RSLEEP|WSLEEP)) == 0);
1741 1742                  ASSERT((firstmsgsigs & ~ALLSIG) == 0);
1742 1743                  ASSERT((allmsgsigs & ~ALLSIG) == 0);
1743 1744                  ASSERT((pollwakeups & ~ALLPOLL) == 0);
1744 1745  #undef  ALLSIG
1745 1746  #undef  ALLPOLL
1746 1747                  mutex_enter(&stp->sd_lock);
1747 1748                  break;
1748 1749          }
1749 1750          ASSERT(MUTEX_HELD(&stp->sd_lock));
1750 1751  
1751 1752          /* By default generate superset of signals */
1752 1753          signals = (firstmsgsigs | allmsgsigs);
1753 1754  
1754 1755          /*
1755 1756           * The  proto and misc functions can return multiple messages
1756 1757           * as a b_next chain. Such messages are processed separately.
1757 1758           */
1758 1759  one_more:
1759 1760          hipri_sig = 0;
1760 1761          if (bp == NULL) {
1761 1762                  nextbp = NULL;
1762 1763          } else {
1763 1764                  nextbp = bp->b_next;
1764 1765                  bp->b_next = NULL;
1765 1766  
1766 1767                  switch (bp->b_datap->db_type) {
1767 1768                  case M_PCPROTO:
1768 1769                          /*
1769 1770                           * Only one priority protocol message is allowed at the
1770 1771                           * stream head at a time.
1771 1772                           */
1772 1773                          if (stp->sd_flag & STRPRI) {
1773 1774                                  TRACE_0(TR_FAC_STREAMS_FR, TR_STRRPUT_PROTERR,
1774 1775                                      "M_PCPROTO already at head");
1775 1776                                  freemsg(bp);
1776 1777                                  mutex_exit(&stp->sd_lock);
1777 1778                                  goto done;
1778 1779                          }
1779 1780                          stp->sd_flag |= STRPRI;
1780 1781                          hipri_sig = 1;
1781 1782                          /* FALLTHRU */
1782 1783                  case M_DATA:
1783 1784                  case M_PROTO:
1784 1785                  case M_PASSFP:
1785 1786                          band = bp->b_band;
1786 1787                          /*
1787 1788                           * Marking doesn't work well when messages
1788 1789                           * are marked in more than one band.  We only
1789 1790                           * remember the last message received, even if
1790 1791                           * it is placed on the queue ahead of other
1791 1792                           * marked messages.
1792 1793                           */
1793 1794                          if (bp->b_flag & MSGMARK)
1794 1795                                  stp->sd_mark = bp;
1795 1796                          (void) putq(q, bp);
1796 1797  
1797 1798                          /*
1798 1799                           * If message is a PCPROTO message, always use
1799 1800                           * firstmsgsigs to determine if a signal should be
1800 1801                           * sent as strrput is the only place to send
1801 1802                           * signals for PCPROTO. Other messages are based on
1802 1803                           * the STRGETINPROG flag. The flag determines if
1803 1804                           * strrput or (k)strgetmsg will be responsible for
1804 1805                           * sending the signals, in the firstmsgsigs case.
1805 1806                           */
1806 1807                          if ((hipri_sig == 1) ||
1807 1808                              (((stp->sd_flag & STRGETINPROG) == 0) &&
1808 1809                              (q->q_first == bp)))
1809 1810                                  signals = (firstmsgsigs | allmsgsigs);
1810 1811                          else
1811 1812                                  signals = allmsgsigs;
1812 1813                          break;
1813 1814  
1814 1815                  default:
1815 1816                          mutex_exit(&stp->sd_lock);
1816 1817                          (void) strrput_nondata(q, bp);
1817 1818                          mutex_enter(&stp->sd_lock);
1818 1819                          break;
1819 1820                  }
1820 1821          }
1821 1822          ASSERT(MUTEX_HELD(&stp->sd_lock));
1822 1823          /*
1823 1824           * Wake sleeping read/getmsg and cancel deferred wakeup
1824 1825           */
1825 1826          if (wakeups & RSLEEP)
1826 1827                  stp->sd_wakeq &= ~RSLEEP;
1827 1828  
1828 1829          wakeups &= stp->sd_flag;
1829 1830          if (wakeups & RSLEEP) {
1830 1831                  stp->sd_flag &= ~RSLEEP;
1831 1832                  cv_broadcast(&q->q_wait);
1832 1833          }
1833 1834          if (wakeups & WSLEEP) {
1834 1835                  stp->sd_flag &= ~WSLEEP;
1835 1836                  cv_broadcast(&_WR(q)->q_wait);
1836 1837          }
1837 1838  
1838 1839          if (pollwakeups != 0) {
1839 1840                  if (pollwakeups == (POLLIN | POLLRDNORM)) {
1840 1841                          /*
1841 1842                           * Can't use rput_opt since it was not
1842 1843                           * read when sd_lock was held and SR_POLLIN is changed
1843 1844                           * by strpoll() under sd_lock.
1844 1845                           */
1845 1846                          if (!(stp->sd_rput_opt & SR_POLLIN))
1846 1847                                  goto no_pollwake;
1847 1848                          stp->sd_rput_opt &= ~SR_POLLIN;
1848 1849                  }
1849 1850                  mutex_exit(&stp->sd_lock);
1850 1851                  pollwakeup(&stp->sd_pollist, pollwakeups);
1851 1852                  mutex_enter(&stp->sd_lock);
1852 1853          }
1853 1854  no_pollwake:
1854 1855  
1855 1856          /*
1856 1857           * strsendsig can handle multiple signals with a
1857 1858           * single call.
1858 1859           */
1859 1860          if (stp->sd_sigflags & signals)
1860 1861                  strsendsig(stp->sd_siglist, signals, band, 0);
1861 1862          mutex_exit(&stp->sd_lock);
1862 1863  
1863 1864  
1864 1865  done:
1865 1866          if (nextbp == NULL)
1866 1867                  return (0);
1867 1868  
1868 1869          /*
1869 1870           * Any signals were handled the first time.
1870 1871           * Wakeups and pollwakeups are redone to avoid any race
1871 1872           * conditions - all the messages are not queued until the
1872 1873           * last message has been processed by strrput.
1873 1874           */
1874 1875          bp = nextbp;
1875 1876          signals = firstmsgsigs = allmsgsigs = 0;
1876 1877          mutex_enter(&stp->sd_lock);
1877 1878          goto one_more;
1878 1879  }
1879 1880  
1880 1881  static void
1881 1882  log_dupioc(queue_t *rq, mblk_t *bp)
1882 1883  {
1883 1884          queue_t *wq, *qp;
1884 1885          char *modnames, *mnp, *dname;
1885 1886          size_t maxmodstr;
1886 1887          boolean_t islast;
1887 1888  
1888 1889          /*
1889 1890           * Allocate a buffer large enough to hold the names of nstrpush modules
1890 1891           * and one driver, with spaces between and NUL terminator.  If we can't
1891 1892           * get memory, then we'll just log the driver name.
1892 1893           */
1893 1894          maxmodstr = nstrpush * (FMNAMESZ + 1);
1894 1895          mnp = modnames = kmem_alloc(maxmodstr, KM_NOSLEEP);
1895 1896  
1896 1897          /* march down write side to print log message down to the driver */
1897 1898          wq = WR(rq);
1898 1899  
1899 1900          /* make sure q_next doesn't shift around while we're grabbing data */
1900 1901          claimstr(wq);
1901 1902          qp = wq->q_next;
1902 1903          do {
1903 1904                  dname = Q2NAME(qp);
1904 1905                  islast = !SAMESTR(qp) || qp->q_next == NULL;
1905 1906                  if (modnames == NULL) {
1906 1907                          /*
1907 1908                           * If we don't have memory, then get the driver name in
1908 1909                           * the log where we can see it.  Note that memory
1909 1910                           * pressure is a possible cause of these sorts of bugs.
1910 1911                           */
1911 1912                          if (islast) {
1912 1913                                  modnames = dname;
1913 1914                                  maxmodstr = 0;
1914 1915                          }
1915 1916                  } else {
1916 1917                          mnp += snprintf(mnp, FMNAMESZ + 1, "%s", dname);
1917 1918                          if (!islast)
1918 1919                                  *mnp++ = ' ';
1919 1920                  }
1920 1921                  qp = qp->q_next;
1921 1922          } while (!islast);
1922 1923          releasestr(wq);
1923 1924          /* Cannot happen unless stream head is corrupt. */
1924 1925          ASSERT(modnames != NULL);
1925 1926          (void) strlog(rq->q_qinfo->qi_minfo->mi_idnum, 0, 1,
1926 1927              SL_CONSOLE|SL_TRACE|SL_ERROR,
1927 1928              "Warning: stream %p received duplicate %X M_IOC%s; module list: %s",
1928 1929              rq->q_ptr, ((struct iocblk *)bp->b_rptr)->ioc_cmd,
1929 1930              (DB_TYPE(bp) == M_IOCACK ? "ACK" : "NAK"), modnames);
1930 1931          if (maxmodstr != 0)
1931 1932                  kmem_free(modnames, maxmodstr);
1932 1933  }
1933 1934  
1934 1935  int
1935 1936  strrput_nondata(queue_t *q, mblk_t *bp)
1936 1937  {
1937 1938          struct stdata *stp;
1938 1939          struct iocblk *iocbp;
1939 1940          struct stroptions *sop;
1940 1941          struct copyreq *reqp;
1941 1942          struct copyresp *resp;
1942 1943          unsigned char bpri;
1943 1944          unsigned char  flushed_already = 0;
1944 1945  
1945 1946          stp = (struct stdata *)q->q_ptr;
1946 1947  
1947 1948          ASSERT(!(stp->sd_flag & STPLEX));
1948 1949          ASSERT(qclaimed(q));
1949 1950  
1950 1951          switch (bp->b_datap->db_type) {
1951 1952          case M_ERROR:
1952 1953                  /*
1953 1954                   * An error has occurred downstream, the errno is in the first
1954 1955                   * bytes of the message.
1955 1956                   */
1956 1957                  if ((bp->b_wptr - bp->b_rptr) == 2) {   /* New flavor */
1957 1958                          unsigned char rw = 0;
1958 1959  
1959 1960                          mutex_enter(&stp->sd_lock);
1960 1961                          if (*bp->b_rptr != NOERROR) {   /* read error */
1961 1962                                  if (*bp->b_rptr != 0) {
1962 1963                                          if (stp->sd_flag & STRDERR)
1963 1964                                                  flushed_already |= FLUSHR;
1964 1965                                          stp->sd_flag |= STRDERR;
1965 1966                                          rw |= FLUSHR;
1966 1967                                  } else {
1967 1968                                          stp->sd_flag &= ~STRDERR;
1968 1969                                  }
1969 1970                                  stp->sd_rerror = *bp->b_rptr;
1970 1971                          }
1971 1972                          bp->b_rptr++;
1972 1973                          if (*bp->b_rptr != NOERROR) {   /* write error */
1973 1974                                  if (*bp->b_rptr != 0) {
1974 1975                                          if (stp->sd_flag & STWRERR)
1975 1976                                                  flushed_already |= FLUSHW;
1976 1977                                          stp->sd_flag |= STWRERR;
1977 1978                                          rw |= FLUSHW;
1978 1979                                  } else {
1979 1980                                          stp->sd_flag &= ~STWRERR;
1980 1981                                  }
1981 1982                                  stp->sd_werror = *bp->b_rptr;
1982 1983                          }
1983 1984                          if (rw) {
1984 1985                                  TRACE_2(TR_FAC_STREAMS_FR, TR_STRRPUT_WAKE,
1985 1986                                      "strrput cv_broadcast:q %p, bp %p",
1986 1987                                      q, bp);
1987 1988                                  cv_broadcast(&q->q_wait); /* readers */
1988 1989                                  cv_broadcast(&_WR(q)->q_wait); /* writers */
1989 1990                                  cv_broadcast(&stp->sd_monitor); /* ioctllers */
1990 1991  
1991 1992                                  mutex_exit(&stp->sd_lock);
1992 1993                                  pollwakeup(&stp->sd_pollist, POLLERR);
1993 1994                                  mutex_enter(&stp->sd_lock);
1994 1995  
1995 1996                                  if (stp->sd_sigflags & S_ERROR)
1996 1997                                          strsendsig(stp->sd_siglist, S_ERROR, 0,
1997 1998                                              ((rw & FLUSHR) ? stp->sd_rerror :
1998 1999                                              stp->sd_werror));
1999 2000                                  mutex_exit(&stp->sd_lock);
2000 2001                                  /*
2001 2002                                   * Send the M_FLUSH only
2002 2003                                   * for the first M_ERROR
2003 2004                                   * message on the stream
2004 2005                                   */
2005 2006                                  if (flushed_already == rw) {
2006 2007                                          freemsg(bp);
2007 2008                                          return (0);
2008 2009                                  }
2009 2010  
2010 2011                                  bp->b_datap->db_type = M_FLUSH;
2011 2012                                  *bp->b_rptr = rw;
2012 2013                                  bp->b_wptr = bp->b_rptr + 1;
2013 2014                                  /*
2014 2015                                   * Protect against the driver
2015 2016                                   * passing up messages after
2016 2017                                   * it has done a qprocsoff
2017 2018                                   */
2018 2019                                  if (_OTHERQ(q)->q_next == NULL)
2019 2020                                          freemsg(bp);
2020 2021                                  else
2021 2022                                          qreply(q, bp);
2022 2023                                  return (0);
2023 2024                          } else
2024 2025                                  mutex_exit(&stp->sd_lock);
2025 2026                  } else if (*bp->b_rptr != 0) {          /* Old flavor */
2026 2027                                  if (stp->sd_flag & (STRDERR|STWRERR))
2027 2028                                          flushed_already = FLUSHRW;
2028 2029                                  mutex_enter(&stp->sd_lock);
2029 2030                                  stp->sd_flag |= (STRDERR|STWRERR);
2030 2031                                  stp->sd_rerror = *bp->b_rptr;
2031 2032                                  stp->sd_werror = *bp->b_rptr;
2032 2033                                  TRACE_2(TR_FAC_STREAMS_FR,
2033 2034                                      TR_STRRPUT_WAKE2,
2034 2035                                      "strrput wakeup #2:q %p, bp %p", q, bp);
2035 2036                                  cv_broadcast(&q->q_wait); /* the readers */
2036 2037                                  cv_broadcast(&_WR(q)->q_wait); /* the writers */
2037 2038                                  cv_broadcast(&stp->sd_monitor); /* ioctllers */
2038 2039  
2039 2040                                  mutex_exit(&stp->sd_lock);
2040 2041                                  pollwakeup(&stp->sd_pollist, POLLERR);
2041 2042                                  mutex_enter(&stp->sd_lock);
2042 2043  
2043 2044                                  if (stp->sd_sigflags & S_ERROR)
2044 2045                                          strsendsig(stp->sd_siglist, S_ERROR, 0,
2045 2046                                              (stp->sd_werror ? stp->sd_werror :
2046 2047                                              stp->sd_rerror));
2047 2048                                  mutex_exit(&stp->sd_lock);
2048 2049  
2049 2050                                  /*
2050 2051                                   * Send the M_FLUSH only
2051 2052                                   * for the first M_ERROR
2052 2053                                   * message on the stream
2053 2054                                   */
2054 2055                                  if (flushed_already != FLUSHRW) {
2055 2056                                          bp->b_datap->db_type = M_FLUSH;
2056 2057                                          *bp->b_rptr = FLUSHRW;
2057 2058                                          /*
2058 2059                                           * Protect against the driver passing up
2059 2060                                           * messages after it has done a
2060 2061                                           * qprocsoff.
2061 2062                                           */
2062 2063                                  if (_OTHERQ(q)->q_next == NULL)
2063 2064                                          freemsg(bp);
2064 2065                                  else
2065 2066                                          qreply(q, bp);
2066 2067                                  return (0);
2067 2068                                  }
2068 2069                  }
2069 2070                  freemsg(bp);
2070 2071                  return (0);
2071 2072  
2072 2073          case M_HANGUP:
2073 2074  
2074 2075                  freemsg(bp);
2075 2076                  mutex_enter(&stp->sd_lock);
2076 2077                  stp->sd_werror = ENXIO;
2077 2078                  stp->sd_flag |= STRHUP;
2078 2079                  stp->sd_flag &= ~(WSLEEP|RSLEEP);
2079 2080  
2080 2081                  /*
2081 2082                   * send signal if controlling tty
2082 2083                   */
2083 2084  
2084 2085                  if (stp->sd_sidp) {
2085 2086                          prsignal(stp->sd_sidp, SIGHUP);
2086 2087                          if (stp->sd_sidp != stp->sd_pgidp)
2087 2088                                  pgsignal(stp->sd_pgidp, SIGTSTP);
2088 2089                  }
2089 2090  
2090 2091                  /*
2091 2092                   * wake up read, write, and exception pollers and
2092 2093                   * reset wakeup mechanism.
2093 2094                   */
2094 2095                  cv_broadcast(&q->q_wait);       /* the readers */
2095 2096                  cv_broadcast(&_WR(q)->q_wait);  /* the writers */
2096 2097                  cv_broadcast(&stp->sd_monitor); /* the ioctllers */
2097 2098                  strhup(stp);
2098 2099                  mutex_exit(&stp->sd_lock);
2099 2100                  return (0);
2100 2101  
2101 2102          case M_UNHANGUP:
2102 2103                  freemsg(bp);
2103 2104                  mutex_enter(&stp->sd_lock);
2104 2105                  stp->sd_werror = 0;
2105 2106                  stp->sd_flag &= ~STRHUP;
2106 2107                  mutex_exit(&stp->sd_lock);
2107 2108                  return (0);
2108 2109  
2109 2110          case M_SIG:
2110 2111                  /*
2111 2112                   * Someone downstream wants to post a signal.  The
2112 2113                   * signal to post is contained in the first byte of the
2113 2114                   * message.  If the message would go on the front of
2114 2115                   * the queue, send a signal to the process group
2115 2116                   * (if not SIGPOLL) or to the siglist processes
2116 2117                   * (SIGPOLL).  If something is already on the queue,
2117 2118                   * OR if we are delivering a delayed suspend (*sigh*
2118 2119                   * another "tty" hack) and there's no one sleeping already,
2119 2120                   * just enqueue the message.
2120 2121                   */
2121 2122                  mutex_enter(&stp->sd_lock);
2122 2123                  if (q->q_first || (*bp->b_rptr == SIGTSTP &&
2123 2124                      !(stp->sd_flag & RSLEEP))) {
2124 2125                          (void) putq(q, bp);
2125 2126                          mutex_exit(&stp->sd_lock);
2126 2127                          return (0);
2127 2128                  }
2128 2129                  mutex_exit(&stp->sd_lock);
2129 2130                  /* FALLTHRU */
2130 2131  
2131 2132          case M_PCSIG:
2132 2133                  /*
2133 2134                   * Don't enqueue, just post the signal.
2134 2135                   */
2135 2136                  strsignal(stp, *bp->b_rptr, 0L);
2136 2137                  freemsg(bp);
2137 2138                  return (0);
2138 2139  
2139 2140          case M_CMD:
2140 2141                  if (MBLKL(bp) != sizeof (cmdblk_t)) {
2141 2142                          freemsg(bp);
2142 2143                          return (0);
2143 2144                  }
2144 2145  
2145 2146                  mutex_enter(&stp->sd_lock);
2146 2147                  if (stp->sd_flag & STRCMDWAIT) {
2147 2148                          ASSERT(stp->sd_cmdblk == NULL);
2148 2149                          stp->sd_cmdblk = bp;
2149 2150                          cv_broadcast(&stp->sd_monitor);
2150 2151                          mutex_exit(&stp->sd_lock);
2151 2152                  } else {
2152 2153                          mutex_exit(&stp->sd_lock);
2153 2154                          freemsg(bp);
2154 2155                  }
2155 2156                  return (0);
2156 2157  
2157 2158          case M_FLUSH:
2158 2159                  /*
2159 2160                   * Flush queues.  The indication of which queues to flush
2160 2161                   * is in the first byte of the message.  If the read queue
2161 2162                   * is specified, then flush it.  If FLUSHBAND is set, just
2162 2163                   * flush the band specified by the second byte of the message.
2163 2164                   *
2164 2165                   * If a module has issued a M_SETOPT to not flush hi
2165 2166                   * priority messages off of the stream head, then pass this
2166 2167                   * flag into the flushq code to preserve such messages.
2167 2168                   */
2168 2169  
2169 2170                  if (*bp->b_rptr & FLUSHR) {
2170 2171                          mutex_enter(&stp->sd_lock);
2171 2172                          if (*bp->b_rptr & FLUSHBAND) {
2172 2173                                  ASSERT((bp->b_wptr - bp->b_rptr) >= 2);
2173 2174                                  flushband(q, *(bp->b_rptr + 1), FLUSHALL);
2174 2175                          } else
2175 2176                                  flushq_common(q, FLUSHALL,
2176 2177                                      stp->sd_read_opt & RFLUSHPCPROT);
2177 2178                          if ((q->q_first == NULL) ||
2178 2179                              (q->q_first->b_datap->db_type < QPCTL))
2179 2180                                  stp->sd_flag &= ~STRPRI;
2180 2181                          else {
2181 2182                                  ASSERT(stp->sd_flag & STRPRI);
2182 2183                          }
2183 2184                          mutex_exit(&stp->sd_lock);
2184 2185                  }
2185 2186                  if ((*bp->b_rptr & FLUSHW) && !(bp->b_flag & MSGNOLOOP)) {
2186 2187                          *bp->b_rptr &= ~FLUSHR;
2187 2188                          bp->b_flag |= MSGNOLOOP;
2188 2189                          /*
2189 2190                           * Protect against the driver passing up
2190 2191                           * messages after it has done a qprocsoff.
2191 2192                           */
2192 2193                          if (_OTHERQ(q)->q_next == NULL)
2193 2194                                  freemsg(bp);
2194 2195                          else
2195 2196                                  qreply(q, bp);
2196 2197                          return (0);
2197 2198                  }
2198 2199                  freemsg(bp);
2199 2200                  return (0);
2200 2201  
2201 2202          case M_IOCACK:
2202 2203          case M_IOCNAK:
2203 2204                  iocbp = (struct iocblk *)bp->b_rptr;
2204 2205                  /*
2205 2206                   * If not waiting for ACK or NAK then just free msg.
2206 2207                   * If incorrect id sequence number then just free msg.
2207 2208                   * If already have ACK or NAK for user then this is a
2208 2209                   *    duplicate, display a warning and free the msg.
2209 2210                   */
2210 2211                  mutex_enter(&stp->sd_lock);
2211 2212                  if ((stp->sd_flag & IOCWAIT) == 0 || stp->sd_iocblk ||
2212 2213                      (stp->sd_iocid != iocbp->ioc_id)) {
2213 2214                          /*
2214 2215                           * If the ACK/NAK is a dup, display a message
2215 2216                           * Dup is when sd_iocid == ioc_id, and
2216 2217                           * sd_iocblk == <valid ptr> or -1 (the former
2217 2218                           * is when an ioctl has been put on the stream
2218 2219                           * head, but has not yet been consumed, the
2219 2220                           * later is when it has been consumed).
2220 2221                           */
2221 2222                          if ((stp->sd_iocid == iocbp->ioc_id) &&
2222 2223                              (stp->sd_iocblk != NULL)) {
2223 2224                                  log_dupioc(q, bp);
2224 2225                          }
2225 2226                          freemsg(bp);
2226 2227                          mutex_exit(&stp->sd_lock);
2227 2228                          return (0);
2228 2229                  }
2229 2230  
2230 2231                  /*
2231 2232                   * Assign ACK or NAK to user and wake up.
2232 2233                   */
2233 2234                  stp->sd_iocblk = bp;
2234 2235                  cv_broadcast(&stp->sd_monitor);
2235 2236                  mutex_exit(&stp->sd_lock);
2236 2237                  return (0);
2237 2238  
2238 2239          case M_COPYIN:
2239 2240          case M_COPYOUT:
2240 2241                  reqp = (struct copyreq *)bp->b_rptr;
2241 2242  
2242 2243                  /*
2243 2244                   * If not waiting for ACK or NAK then just fail request.
2244 2245                   * If already have ACK, NAK, or copy request, then just
2245 2246                   * fail request.
2246 2247                   * If incorrect id sequence number then just fail request.
2247 2248                   */
2248 2249                  mutex_enter(&stp->sd_lock);
2249 2250                  if ((stp->sd_flag & IOCWAIT) == 0 || stp->sd_iocblk ||
2250 2251                      (stp->sd_iocid != reqp->cq_id)) {
2251 2252                          if (bp->b_cont) {
2252 2253                                  freemsg(bp->b_cont);
2253 2254                                  bp->b_cont = NULL;
2254 2255                          }
2255 2256                          bp->b_datap->db_type = M_IOCDATA;
2256 2257                          bp->b_wptr = bp->b_rptr + sizeof (struct copyresp);
2257 2258                          resp = (struct copyresp *)bp->b_rptr;
2258 2259                          resp->cp_rval = (caddr_t)1;     /* failure */
2259 2260                          mutex_exit(&stp->sd_lock);
2260 2261                          putnext(stp->sd_wrq, bp);
2261 2262                          return (0);
2262 2263                  }
2263 2264  
2264 2265                  /*
2265 2266                   * Assign copy request to user and wake up.
2266 2267                   */
2267 2268                  stp->sd_iocblk = bp;
2268 2269                  cv_broadcast(&stp->sd_monitor);
2269 2270                  mutex_exit(&stp->sd_lock);
2270 2271                  return (0);
2271 2272  
2272 2273          case M_SETOPTS:
2273 2274                  /*
2274 2275                   * Set stream head options (read option, write offset,
2275 2276                   * min/max packet size, and/or high/low water marks for
2276 2277                   * the read side only).
2277 2278                   */
2278 2279  
2279 2280                  bpri = 0;
2280 2281                  sop = (struct stroptions *)bp->b_rptr;
2281 2282                  mutex_enter(&stp->sd_lock);
2282 2283                  if (sop->so_flags & SO_READOPT) {
2283 2284                          switch (sop->so_readopt & RMODEMASK) {
2284 2285                          case RNORM:
2285 2286                                  stp->sd_read_opt &= ~(RD_MSGDIS | RD_MSGNODIS);
2286 2287                                  break;
2287 2288  
2288 2289                          case RMSGD:
2289 2290                                  stp->sd_read_opt =
2290 2291                                      ((stp->sd_read_opt & ~RD_MSGNODIS) |
2291 2292                                      RD_MSGDIS);
2292 2293                                  break;
2293 2294  
2294 2295                          case RMSGN:
2295 2296                                  stp->sd_read_opt =
2296 2297                                      ((stp->sd_read_opt & ~RD_MSGDIS) |
2297 2298                                      RD_MSGNODIS);
2298 2299                                  break;
2299 2300                          }
2300 2301                          switch (sop->so_readopt & RPROTMASK) {
2301 2302                          case RPROTNORM:
2302 2303                                  stp->sd_read_opt &= ~(RD_PROTDAT | RD_PROTDIS);
2303 2304                                  break;
2304 2305  
2305 2306                          case RPROTDAT:
2306 2307                                  stp->sd_read_opt =
2307 2308                                      ((stp->sd_read_opt & ~RD_PROTDIS) |
2308 2309                                      RD_PROTDAT);
2309 2310                                  break;
2310 2311  
2311 2312                          case RPROTDIS:
2312 2313                                  stp->sd_read_opt =
2313 2314                                      ((stp->sd_read_opt & ~RD_PROTDAT) |
2314 2315                                      RD_PROTDIS);
2315 2316                                  break;
2316 2317                          }
2317 2318                          switch (sop->so_readopt & RFLUSHMASK) {
2318 2319                          case RFLUSHPCPROT:
2319 2320                                  /*
2320 2321                                   * This sets the stream head to NOT flush
2321 2322                                   * M_PCPROTO messages.
2322 2323                                   */
2323 2324                                  stp->sd_read_opt |= RFLUSHPCPROT;
2324 2325                                  break;
2325 2326                          }
2326 2327                  }
2327 2328                  if (sop->so_flags & SO_ERROPT) {
2328 2329                          switch (sop->so_erropt & RERRMASK) {
2329 2330                          case RERRNORM:
2330 2331                                  stp->sd_flag &= ~STRDERRNONPERSIST;
2331 2332                                  break;
2332 2333                          case RERRNONPERSIST:
2333 2334                                  stp->sd_flag |= STRDERRNONPERSIST;
2334 2335                                  break;
2335 2336                          }
2336 2337                          switch (sop->so_erropt & WERRMASK) {
2337 2338                          case WERRNORM:
2338 2339                                  stp->sd_flag &= ~STWRERRNONPERSIST;
2339 2340                                  break;
2340 2341                          case WERRNONPERSIST:
2341 2342                                  stp->sd_flag |= STWRERRNONPERSIST;
2342 2343                                  break;
2343 2344                          }
2344 2345                  }
2345 2346                  if (sop->so_flags & SO_COPYOPT) {
2346 2347                          if (sop->so_copyopt & ZCVMSAFE) {
2347 2348                                  stp->sd_copyflag |= STZCVMSAFE;
2348 2349                                  stp->sd_copyflag &= ~STZCVMUNSAFE;
2349 2350                          } else if (sop->so_copyopt & ZCVMUNSAFE) {
2350 2351                                  stp->sd_copyflag |= STZCVMUNSAFE;
2351 2352                                  stp->sd_copyflag &= ~STZCVMSAFE;
2352 2353                          }
2353 2354  
2354 2355                          if (sop->so_copyopt & COPYCACHED) {
2355 2356                                  stp->sd_copyflag |= STRCOPYCACHED;
2356 2357                          }
2357 2358                  }
2358 2359                  if (sop->so_flags & SO_WROFF)
2359 2360                          stp->sd_wroff = sop->so_wroff;
2360 2361                  if (sop->so_flags & SO_TAIL)
2361 2362                          stp->sd_tail = sop->so_tail;
2362 2363                  if (sop->so_flags & SO_MINPSZ)
2363 2364                          q->q_minpsz = sop->so_minpsz;
2364 2365                  if (sop->so_flags & SO_MAXPSZ)
2365 2366                          q->q_maxpsz = sop->so_maxpsz;
2366 2367                  if (sop->so_flags & SO_MAXBLK)
2367 2368                          stp->sd_maxblk = sop->so_maxblk;
2368 2369                  if (sop->so_flags & SO_HIWAT) {
2369 2370                          if (sop->so_flags & SO_BAND) {
2370 2371                                  if (strqset(q, QHIWAT,
2371 2372                                      sop->so_band, sop->so_hiwat)) {
2372 2373                                          cmn_err(CE_WARN, "strrput: could not "
2373 2374                                              "allocate qband\n");
2374 2375                                  } else {
2375 2376                                          bpri = sop->so_band;
2376 2377                                  }
2377 2378                          } else {
2378 2379                                  q->q_hiwat = sop->so_hiwat;
2379 2380                          }
2380 2381                  }
2381 2382                  if (sop->so_flags & SO_LOWAT) {
2382 2383                          if (sop->so_flags & SO_BAND) {
2383 2384                                  if (strqset(q, QLOWAT,
2384 2385                                      sop->so_band, sop->so_lowat)) {
2385 2386                                          cmn_err(CE_WARN, "strrput: could not "
2386 2387                                              "allocate qband\n");
2387 2388                                  } else {
2388 2389                                          bpri = sop->so_band;
2389 2390                                  }
2390 2391                          } else {
2391 2392                                  q->q_lowat = sop->so_lowat;
2392 2393                          }
2393 2394                  }
2394 2395                  if (sop->so_flags & SO_MREADON)
2395 2396                          stp->sd_flag |= SNDMREAD;
2396 2397                  if (sop->so_flags & SO_MREADOFF)
2397 2398                          stp->sd_flag &= ~SNDMREAD;
2398 2399                  if (sop->so_flags & SO_NDELON)
2399 2400                          stp->sd_flag |= OLDNDELAY;
2400 2401                  if (sop->so_flags & SO_NDELOFF)
2401 2402                          stp->sd_flag &= ~OLDNDELAY;
2402 2403                  if (sop->so_flags & SO_ISTTY)
2403 2404                          stp->sd_flag |= STRISTTY;
2404 2405                  if (sop->so_flags & SO_ISNTTY)
2405 2406                          stp->sd_flag &= ~STRISTTY;
2406 2407                  if (sop->so_flags & SO_TOSTOP)
2407 2408                          stp->sd_flag |= STRTOSTOP;
2408 2409                  if (sop->so_flags & SO_TONSTOP)
2409 2410                          stp->sd_flag &= ~STRTOSTOP;
2410 2411                  if (sop->so_flags & SO_DELIM)
2411 2412                          stp->sd_flag |= STRDELIM;
2412 2413                  if (sop->so_flags & SO_NODELIM)
2413 2414                          stp->sd_flag &= ~STRDELIM;
2414 2415  
2415 2416                  mutex_exit(&stp->sd_lock);
2416 2417                  freemsg(bp);
2417 2418  
2418 2419                  /* Check backenable in case the water marks changed */
2419 2420                  qbackenable(q, bpri);
2420 2421                  return (0);
2421 2422  
2422 2423          /*
2423 2424           * The following set of cases deal with situations where two stream
2424 2425           * heads are connected to each other (twisted streams).  These messages
2425 2426           * have no meaning at the stream head.
2426 2427           */
2427 2428          case M_BREAK:
2428 2429          case M_CTL:
2429 2430          case M_DELAY:
2430 2431          case M_START:
2431 2432          case M_STOP:
2432 2433          case M_IOCDATA:
2433 2434          case M_STARTI:
2434 2435          case M_STOPI:
2435 2436                  freemsg(bp);
2436 2437                  return (0);
2437 2438  
2438 2439          case M_IOCTL:
2439 2440                  /*
2440 2441                   * Always NAK this condition
2441 2442                   * (makes no sense)
2442 2443                   * If there is one or more threads in the read side
2443 2444                   * rwnext we have to defer the nacking until that thread
2444 2445                   * returns (in strget).
2445 2446                   */
2446 2447                  mutex_enter(&stp->sd_lock);
2447 2448                  if (stp->sd_struiodnak != 0) {
2448 2449                          /*
2449 2450                           * Defer NAK to the streamhead. Queue at the end
2450 2451                           * the list.
2451 2452                           */
2452 2453                          mblk_t *mp = stp->sd_struionak;
2453 2454  
2454 2455                          while (mp && mp->b_next)
2455 2456                                  mp = mp->b_next;
2456 2457                          if (mp)
2457 2458                                  mp->b_next = bp;
2458 2459                          else
2459 2460                                  stp->sd_struionak = bp;
2460 2461                          bp->b_next = NULL;
2461 2462                          mutex_exit(&stp->sd_lock);
2462 2463                          return (0);
2463 2464                  }
2464 2465                  mutex_exit(&stp->sd_lock);
2465 2466  
2466 2467                  bp->b_datap->db_type = M_IOCNAK;
2467 2468                  /*
2468 2469                   * Protect against the driver passing up
2469 2470                   * messages after it has done a qprocsoff.
2470 2471                   */
2471 2472                  if (_OTHERQ(q)->q_next == NULL)
2472 2473                          freemsg(bp);
2473 2474                  else
2474 2475                          qreply(q, bp);
2475 2476                  return (0);
2476 2477  
2477 2478          default:
2478 2479  #ifdef DEBUG
2479 2480                  cmn_err(CE_WARN,
2480 2481                      "bad message type %x received at stream head\n",
2481 2482                      bp->b_datap->db_type);
2482 2483  #endif
2483 2484                  freemsg(bp);
2484 2485                  return (0);
2485 2486          }
2486 2487  
2487 2488          /* NOTREACHED */
2488 2489  }
2489 2490  
2490 2491  /*
2491 2492   * Check if the stream pointed to by `stp' can be written to, and return an
2492 2493   * error code if not.  If `eiohup' is set, then return EIO if STRHUP is set.
2493 2494   * If `sigpipeok' is set and the SW_SIGPIPE option is enabled on the stream,
2494 2495   * then always return EPIPE and send a SIGPIPE to the invoking thread.
2495 2496   */
2496 2497  static int
2497 2498  strwriteable(struct stdata *stp, boolean_t eiohup, boolean_t sigpipeok)
2498 2499  {
2499 2500          int error;
2500 2501  
2501 2502          ASSERT(MUTEX_HELD(&stp->sd_lock));
2502 2503  
2503 2504          /*
2504 2505           * For modem support, POSIX states that on writes, EIO should
2505 2506           * be returned if the stream has been hung up.
2506 2507           */
2507 2508          if (eiohup && (stp->sd_flag & (STPLEX|STRHUP)) == STRHUP)
2508 2509                  error = EIO;
2509 2510          else
2510 2511                  error = strgeterr(stp, STRHUP|STPLEX|STWRERR, 0);
2511 2512  
2512 2513          if (error != 0) {
2513 2514                  if (!(stp->sd_flag & STPLEX) &&
2514 2515                      (stp->sd_wput_opt & SW_SIGPIPE) && sigpipeok) {
2515 2516                          tsignal(curthread, SIGPIPE);
2516 2517                          error = EPIPE;
2517 2518                  }
2518 2519          }
2519 2520  
2520 2521          return (error);
2521 2522  }
2522 2523  
2523 2524  /*
2524 2525   * Copyin and send data down a stream.
2525 2526   * The caller will allocate and copyin any control part that precedes the
2526 2527   * message and pass that in as mctl.
2527 2528   *
2528 2529   * Caller should *not* hold sd_lock.
2529 2530   * When EWOULDBLOCK is returned the caller has to redo the canputnext
2530 2531   * under sd_lock in order to avoid missing a backenabling wakeup.
2531 2532   *
2532 2533   * Use iosize = -1 to not send any M_DATA. iosize = 0 sends zero-length M_DATA.
2533 2534   *
2534 2535   * Set MSG_IGNFLOW in flags to ignore flow control for hipri messages.
2535 2536   * For sync streams we can only ignore flow control by reverting to using
2536 2537   * putnext.
2537 2538   *
2538 2539   * If sd_maxblk is less than *iosize this routine might return without
2539 2540   * transferring all of *iosize. In all cases, on return *iosize will contain
2540 2541   * the amount of data that was transferred.
2541 2542   */
2542 2543  static int
2543 2544  strput(struct stdata *stp, mblk_t *mctl, struct uio *uiop, ssize_t *iosize,
2544 2545      int b_flag, int pri, int flags)
2545 2546  {
2546 2547          struiod_t uiod;
2547 2548          mblk_t *mp;
2548 2549          queue_t *wqp = stp->sd_wrq;
2549 2550          int error = 0;
2550 2551          ssize_t count = *iosize;
2551 2552  
2552 2553          ASSERT(MUTEX_NOT_HELD(&stp->sd_lock));
2553 2554  
2554 2555          if (uiop != NULL && count >= 0)
2555 2556                  flags |= stp->sd_struiowrq ? STRUIO_POSTPONE : 0;
2556 2557  
2557 2558          if (!(flags & STRUIO_POSTPONE)) {
2558 2559                  /*
2559 2560                   * Use regular canputnext, strmakedata, putnext sequence.
2560 2561                   */
2561 2562                  if (pri == 0) {
2562 2563                          if (!canputnext(wqp) && !(flags & MSG_IGNFLOW)) {
2563 2564                                  freemsg(mctl);
2564 2565                                  return (EWOULDBLOCK);
2565 2566                          }
2566 2567                  } else {
2567 2568                          if (!(flags & MSG_IGNFLOW) && !bcanputnext(wqp, pri)) {
2568 2569                                  freemsg(mctl);
2569 2570                                  return (EWOULDBLOCK);
2570 2571                          }
2571 2572                  }
2572 2573  
2573 2574                  if ((error = strmakedata(iosize, uiop, stp, flags,
2574 2575                      &mp)) != 0) {
2575 2576                          freemsg(mctl);
2576 2577                          /*
2577 2578                           * need to change return code to ENOMEM
2578 2579                           * so that this is not confused with
2579 2580                           * flow control, EAGAIN.
2580 2581                           */
2581 2582  
2582 2583                          if (error == EAGAIN)
2583 2584                                  return (ENOMEM);
2584 2585                          else
2585 2586                                  return (error);
2586 2587                  }
2587 2588                  if (mctl != NULL) {
2588 2589                          if (mctl->b_cont == NULL)
2589 2590                                  mctl->b_cont = mp;
2590 2591                          else if (mp != NULL)
2591 2592                                  linkb(mctl, mp);
2592 2593                          mp = mctl;
2593 2594                  } else if (mp == NULL)
2594 2595                          return (0);
2595 2596  
2596 2597                  mp->b_flag |= b_flag;
2597 2598                  mp->b_band = (uchar_t)pri;
2598 2599  
2599 2600                  if (flags & MSG_IGNFLOW) {
2600 2601                          /*
2601 2602                           * XXX Hack: Don't get stuck running service
2602 2603                           * procedures. This is needed for sockfs when
2603 2604                           * sending the unbind message out of the rput
2604 2605                           * procedure - we don't want a put procedure
2605 2606                           * to run service procedures.
2606 2607                           */
2607 2608                          putnext(wqp, mp);
2608 2609                  } else {
2609 2610                          stream_willservice(stp);
2610 2611                          putnext(wqp, mp);
2611 2612                          stream_runservice(stp);
2612 2613                  }
2613 2614                  return (0);
2614 2615          }
2615 2616          /*
2616 2617           * Stream supports rwnext() for the write side.
2617 2618           */
2618 2619          if ((error = strmakedata(iosize, uiop, stp, flags, &mp)) != 0) {
2619 2620                  freemsg(mctl);
2620 2621                  /*
2621 2622                   * map EAGAIN to ENOMEM since EAGAIN means "flow controlled".
2622 2623                   */
2623 2624                  return (error == EAGAIN ? ENOMEM : error);
2624 2625          }
2625 2626          if (mctl != NULL) {
2626 2627                  if (mctl->b_cont == NULL)
2627 2628                          mctl->b_cont = mp;
2628 2629                  else if (mp != NULL)
2629 2630                          linkb(mctl, mp);
2630 2631                  mp = mctl;
2631 2632          } else if (mp == NULL) {
2632 2633                  return (0);
2633 2634          }
2634 2635  
2635 2636          mp->b_flag |= b_flag;
2636 2637          mp->b_band = (uchar_t)pri;
2637 2638  
2638 2639          (void) uiodup(uiop, &uiod.d_uio, uiod.d_iov,
2639 2640              sizeof (uiod.d_iov) / sizeof (*uiod.d_iov));
2640 2641          uiod.d_uio.uio_offset = 0;
2641 2642          uiod.d_mp = mp;
2642 2643          error = rwnext(wqp, &uiod);
2643 2644          if (! uiod.d_mp) {
2644 2645                  uioskip(uiop, *iosize);
2645 2646                  return (error);
2646 2647          }
2647 2648          ASSERT(mp == uiod.d_mp);
2648 2649          if (error == EINVAL) {
2649 2650                  /*
2650 2651                   * The stream plumbing must have changed while
2651 2652                   * we were away, so just turn off rwnext()s.
2652 2653                   */
2653 2654                  error = 0;
2654 2655          } else if (error == EBUSY || error == EWOULDBLOCK) {
2655 2656                  /*
2656 2657                   * Couldn't enter a perimeter or took a page fault,
2657 2658                   * so fall-back to putnext().
2658 2659                   */
2659 2660                  error = 0;
2660 2661          } else {
2661 2662                  freemsg(mp);
2662 2663                  return (error);
2663 2664          }
2664 2665          /* Have to check canput before consuming data from the uio */
2665 2666          if (pri == 0) {
2666 2667                  if (!canputnext(wqp) && !(flags & MSG_IGNFLOW)) {
2667 2668                          freemsg(mp);
2668 2669                          return (EWOULDBLOCK);
2669 2670                  }
2670 2671          } else {
2671 2672                  if (!bcanputnext(wqp, pri) && !(flags & MSG_IGNFLOW)) {
2672 2673                          freemsg(mp);
2673 2674                          return (EWOULDBLOCK);
2674 2675                  }
2675 2676          }
2676 2677          ASSERT(mp == uiod.d_mp);
2677 2678          /* Copyin data from the uio */
2678 2679          if ((error = struioget(wqp, mp, &uiod, 0)) != 0) {
2679 2680                  freemsg(mp);
2680 2681                  return (error);
2681 2682          }
2682 2683          uioskip(uiop, *iosize);
2683 2684          if (flags & MSG_IGNFLOW) {
2684 2685                  /*
2685 2686                   * XXX Hack: Don't get stuck running service procedures.
2686 2687                   * This is needed for sockfs when sending the unbind message
2687 2688                   * out of the rput procedure - we don't want a put procedure
2688 2689                   * to run service procedures.
2689 2690                   */
2690 2691                  putnext(wqp, mp);
2691 2692          } else {
2692 2693                  stream_willservice(stp);
2693 2694                  putnext(wqp, mp);
2694 2695                  stream_runservice(stp);
2695 2696          }
2696 2697          return (0);
2697 2698  }
2698 2699  
2699 2700  /*
2700 2701   * Write attempts to break the write request into messages conforming
2701 2702   * with the minimum and maximum packet sizes set downstream.
2702 2703   *
2703 2704   * Write will not block if downstream queue is full and
2704 2705   * O_NDELAY is set, otherwise it will block waiting for the queue to get room.
2705 2706   *
2706 2707   * A write of zero bytes gets packaged into a zero length message and sent
2707 2708   * downstream like any other message.
2708 2709   *
2709 2710   * If buffers of the requested sizes are not available, the write will
2710 2711   * sleep until the buffers become available.
2711 2712   *
2712 2713   * Write (if specified) will supply a write offset in a message if it
2713 2714   * makes sense. This can be specified by downstream modules as part of
2714 2715   * a M_SETOPTS message.  Write will not supply the write offset if it
2715 2716   * cannot supply any data in a buffer.  In other words, write will never
2716 2717   * send down an empty packet due to a write offset.
2717 2718   */
2718 2719  /* ARGSUSED2 */
2719 2720  int
2720 2721  strwrite(struct vnode *vp, struct uio *uiop, cred_t *crp)
2721 2722  {
2722 2723          return (strwrite_common(vp, uiop, crp, 0));
2723 2724  }
2724 2725  
2725 2726  /* ARGSUSED2 */
2726 2727  int
2727 2728  strwrite_common(struct vnode *vp, struct uio *uiop, cred_t *crp, int wflag)
2728 2729  {
2729 2730          struct stdata *stp;
2730 2731          struct queue *wqp;
2731 2732          ssize_t rmin, rmax;
2732 2733          ssize_t iosize;
2733 2734          int waitflag;
2734 2735          int tempmode;
2735 2736          int error = 0;
2736 2737          int b_flag;
2737 2738  
2738 2739          ASSERT(vp->v_stream);
2739 2740          stp = vp->v_stream;
2740 2741  
2741 2742          mutex_enter(&stp->sd_lock);
2742 2743  
2743 2744          if ((error = i_straccess(stp, JCWRITE)) != 0) {
2744 2745                  mutex_exit(&stp->sd_lock);
2745 2746                  return (error);
2746 2747          }
2747 2748  
2748 2749          if (stp->sd_flag & (STWRERR|STRHUP|STPLEX)) {
2749 2750                  error = strwriteable(stp, B_TRUE, B_TRUE);
2750 2751                  if (error != 0) {
2751 2752                          mutex_exit(&stp->sd_lock);
2752 2753                          return (error);
2753 2754                  }
2754 2755          }
2755 2756  
2756 2757          mutex_exit(&stp->sd_lock);
2757 2758  
2758 2759          wqp = stp->sd_wrq;
2759 2760  
2760 2761          /* get these values from them cached in the stream head */
2761 2762          rmin = stp->sd_qn_minpsz;
2762 2763          rmax = stp->sd_qn_maxpsz;
2763 2764  
2764 2765          /*
2765 2766           * Check the min/max packet size constraints.  If min packet size
2766 2767           * is non-zero, the write cannot be split into multiple messages
2767 2768           * and still guarantee the size constraints.
2768 2769           */
2769 2770          TRACE_1(TR_FAC_STREAMS_FR, TR_STRWRITE_IN, "strwrite in:q %p", wqp);
2770 2771  
2771 2772          ASSERT((rmax >= 0) || (rmax == INFPSZ));
2772 2773          if (rmax == 0) {
2773 2774                  return (0);
2774 2775          }
2775 2776          if (rmin > 0) {
2776 2777                  if (uiop->uio_resid < rmin) {
2777 2778                          TRACE_3(TR_FAC_STREAMS_FR, TR_STRWRITE_OUT,
2778 2779                              "strwrite out:q %p out %d error %d",
2779 2780                              wqp, 0, ERANGE);
2780 2781                          return (ERANGE);
2781 2782                  }
2782 2783                  if ((rmax != INFPSZ) && (uiop->uio_resid > rmax)) {
2783 2784                          TRACE_3(TR_FAC_STREAMS_FR, TR_STRWRITE_OUT,
2784 2785                              "strwrite out:q %p out %d error %d",
2785 2786                              wqp, 1, ERANGE);
2786 2787                          return (ERANGE);
2787 2788                  }
2788 2789          }
2789 2790  
2790 2791          /*
2791 2792           * Do until count satisfied or error.
2792 2793           */
2793 2794          waitflag = WRITEWAIT | wflag;
2794 2795          if (stp->sd_flag & OLDNDELAY)
2795 2796                  tempmode = uiop->uio_fmode & ~FNDELAY;
2796 2797          else
2797 2798                  tempmode = uiop->uio_fmode;
2798 2799  
2799 2800          if (rmax == INFPSZ)
2800 2801                  rmax = uiop->uio_resid;
2801 2802  
2802 2803          /*
2803 2804           * Note that tempmode does not get used in strput/strmakedata
2804 2805           * but only in strwaitq. The other routines use uio_fmode
2805 2806           * unmodified.
2806 2807           */
2807 2808  
2808 2809          /* LINTED: constant in conditional context */
2809 2810          while (1) {     /* breaks when uio_resid reaches zero */
2810 2811                  /*
2811 2812                   * Determine the size of the next message to be
2812 2813                   * packaged.  May have to break write into several
2813 2814                   * messages based on max packet size.
2814 2815                   */
2815 2816                  iosize = MIN(uiop->uio_resid, rmax);
2816 2817  
2817 2818                  /*
2818 2819                   * Put block downstream when flow control allows it.
2819 2820                   */
2820 2821                  if ((stp->sd_flag & STRDELIM) && (uiop->uio_resid == iosize))
2821 2822                          b_flag = MSGDELIM;
2822 2823                  else
2823 2824                          b_flag = 0;
2824 2825  
2825 2826                  for (;;) {
2826 2827                          int done = 0;
2827 2828  
2828 2829                          error = strput(stp, NULL, uiop, &iosize, b_flag, 0, 0);
2829 2830                          if (error == 0)
2830 2831                                  break;
2831 2832                          if (error != EWOULDBLOCK)
2832 2833                                  goto out;
2833 2834  
2834 2835                          mutex_enter(&stp->sd_lock);
2835 2836                          /*
2836 2837                           * Check for a missed wakeup.
2837 2838                           * Needed since strput did not hold sd_lock across
2838 2839                           * the canputnext.
2839 2840                           */
2840 2841                          if (canputnext(wqp)) {
2841 2842                                  /* Try again */
2842 2843                                  mutex_exit(&stp->sd_lock);
2843 2844                                  continue;
2844 2845                          }
2845 2846                          TRACE_1(TR_FAC_STREAMS_FR, TR_STRWRITE_WAIT,
2846 2847                              "strwrite wait:q %p wait", wqp);
2847 2848                          if ((error = strwaitq(stp, waitflag, (ssize_t)0,
2848 2849                              tempmode, -1, &done)) != 0 || done) {
2849 2850                                  mutex_exit(&stp->sd_lock);
2850 2851                                  if ((vp->v_type == VFIFO) &&
2851 2852                                      (uiop->uio_fmode & FNDELAY) &&
2852 2853                                      (error == EAGAIN))
2853 2854                                          error = 0;
2854 2855                                  goto out;
2855 2856                          }
2856 2857                          TRACE_1(TR_FAC_STREAMS_FR, TR_STRWRITE_WAKE,
2857 2858                              "strwrite wake:q %p awakes", wqp);
2858 2859                          if ((error = i_straccess(stp, JCWRITE)) != 0) {
2859 2860                                  mutex_exit(&stp->sd_lock);
2860 2861                                  goto out;
2861 2862                          }
2862 2863                          mutex_exit(&stp->sd_lock);
2863 2864                  }
2864 2865                  waitflag |= NOINTR;
2865 2866                  TRACE_2(TR_FAC_STREAMS_FR, TR_STRWRITE_RESID,
2866 2867                      "strwrite resid:q %p uiop %p", wqp, uiop);
2867 2868                  if (uiop->uio_resid) {
2868 2869                          /* Recheck for errors - needed for sockets */
2869 2870                          if ((stp->sd_wput_opt & SW_RECHECK_ERR) &&
2870 2871                              (stp->sd_flag & (STWRERR|STRHUP|STPLEX))) {
2871 2872                                  mutex_enter(&stp->sd_lock);
2872 2873                                  error = strwriteable(stp, B_FALSE, B_TRUE);
2873 2874                                  mutex_exit(&stp->sd_lock);
2874 2875                                  if (error != 0)
2875 2876                                          return (error);
2876 2877                          }
2877 2878                          continue;
2878 2879                  }
2879 2880                  break;
2880 2881          }
2881 2882  out:
2882 2883          /*
2883 2884           * For historical reasons, applications expect EAGAIN when a data
2884 2885           * mblk_t cannot be allocated, so change ENOMEM back to EAGAIN.
2885 2886           */
2886 2887          if (error == ENOMEM)
2887 2888                  error = EAGAIN;
2888 2889          TRACE_3(TR_FAC_STREAMS_FR, TR_STRWRITE_OUT,
2889 2890              "strwrite out:q %p out %d error %d", wqp, 2, error);
2890 2891          return (error);
2891 2892  }
2892 2893  
2893 2894  /*
2894 2895   * Stream head write service routine.
2895 2896   * Its job is to wake up any sleeping writers when a queue
2896 2897   * downstream needs data (part of the flow control in putq and getq).
2897 2898   * It also must wake anyone sleeping on a poll().
2898 2899   * For stream head right below mux module, it must also invoke put procedure
2899 2900   * of next downstream module.
2900 2901   */
2901 2902  int
2902 2903  strwsrv(queue_t *q)
2903 2904  {
2904 2905          struct stdata *stp;
2905 2906          queue_t *tq;
2906 2907          qband_t *qbp;
2907 2908          int i;
2908 2909          qband_t *myqbp;
2909 2910          int isevent;
2910 2911          unsigned char   qbf[NBAND];     /* band flushing backenable flags */
2911 2912  
2912 2913          TRACE_1(TR_FAC_STREAMS_FR,
2913 2914              TR_STRWSRV, "strwsrv:q %p", q);
2914 2915          stp = (struct stdata *)q->q_ptr;
2915 2916          ASSERT(qclaimed(q));
2916 2917          mutex_enter(&stp->sd_lock);
2917 2918          ASSERT(!(stp->sd_flag & STPLEX));
2918 2919  
2919 2920          if (stp->sd_flag & WSLEEP) {
2920 2921                  stp->sd_flag &= ~WSLEEP;
2921 2922                  cv_broadcast(&q->q_wait);
2922 2923          }
2923 2924          mutex_exit(&stp->sd_lock);
2924 2925  
2925 2926          /* The other end of a stream pipe went away. */
2926 2927          if ((tq = q->q_next) == NULL) {
2927 2928                  return (0);
2928 2929          }
2929 2930  
2930 2931          /* Find the next module forward that has a service procedure */
2931 2932          claimstr(q);
2932 2933          tq = q->q_nfsrv;
2933 2934          ASSERT(tq != NULL);
2934 2935  
2935 2936          if ((q->q_flag & QBACK)) {
2936 2937                  if ((tq->q_flag & QFULL)) {
2937 2938                          mutex_enter(QLOCK(tq));
2938 2939                          if (!(tq->q_flag & QFULL)) {
2939 2940                                  mutex_exit(QLOCK(tq));
2940 2941                                  goto wakeup;
2941 2942                          }
2942 2943                          /*
2943 2944                           * The queue must have become full again. Set QWANTW
2944 2945                           * again so strwsrv will be back enabled when
2945 2946                           * the queue becomes non-full next time.
2946 2947                           */
2947 2948                          tq->q_flag |= QWANTW;
2948 2949                          mutex_exit(QLOCK(tq));
2949 2950                  } else {
2950 2951                  wakeup:
2951 2952                          pollwakeup(&stp->sd_pollist, POLLWRNORM);
2952 2953                          mutex_enter(&stp->sd_lock);
2953 2954                          if (stp->sd_sigflags & S_WRNORM)
2954 2955                                  strsendsig(stp->sd_siglist, S_WRNORM, 0, 0);
2955 2956                          mutex_exit(&stp->sd_lock);
2956 2957                  }
2957 2958          }
2958 2959  
2959 2960          isevent = 0;
2960 2961          i = 1;
2961 2962          bzero((caddr_t)qbf, NBAND);
2962 2963          mutex_enter(QLOCK(tq));
2963 2964          if ((myqbp = q->q_bandp) != NULL)
2964 2965                  for (qbp = tq->q_bandp; qbp && myqbp; qbp = qbp->qb_next) {
2965 2966                          ASSERT(myqbp);
2966 2967                          if ((myqbp->qb_flag & QB_BACK)) {
2967 2968                                  if (qbp->qb_flag & QB_FULL) {
2968 2969                                          /*
2969 2970                                           * The band must have become full again.
2970 2971                                           * Set QB_WANTW again so strwsrv will
2971 2972                                           * be back enabled when the band becomes
2972 2973                                           * non-full next time.
2973 2974                                           */
2974 2975                                          qbp->qb_flag |= QB_WANTW;
2975 2976                                  } else {
2976 2977                                          isevent = 1;
2977 2978                                          qbf[i] = 1;
2978 2979                                  }
2979 2980                          }
2980 2981                          myqbp = myqbp->qb_next;
2981 2982                          i++;
2982 2983                  }
2983 2984          mutex_exit(QLOCK(tq));
2984 2985  
2985 2986          if (isevent) {
2986 2987                  for (i = tq->q_nband; i; i--) {
2987 2988                          if (qbf[i]) {
2988 2989                                  pollwakeup(&stp->sd_pollist, POLLWRBAND);
2989 2990                                  mutex_enter(&stp->sd_lock);
2990 2991                                  if (stp->sd_sigflags & S_WRBAND)
2991 2992                                          strsendsig(stp->sd_siglist, S_WRBAND,
2992 2993                                              (uchar_t)i, 0);
2993 2994                                  mutex_exit(&stp->sd_lock);
2994 2995                          }
2995 2996                  }
2996 2997          }
2997 2998  
2998 2999          releasestr(q);
2999 3000          return (0);
3000 3001  }
3001 3002  
3002 3003  /*
3003 3004   * Special case of strcopyin/strcopyout for copying
3004 3005   * struct strioctl that can deal with both data
3005 3006   * models.
3006 3007   */
3007 3008  
3008 3009  #ifdef  _LP64
3009 3010  
3010 3011  static int
3011 3012  strcopyin_strioctl(void *from, void *to, int flag, int copyflag)
3012 3013  {
3013 3014          struct  strioctl32 strioc32;
3014 3015          struct  strioctl *striocp;
3015 3016  
3016 3017          if (copyflag & U_TO_K) {
3017 3018                  ASSERT((copyflag & K_TO_K) == 0);
3018 3019  
3019 3020                  if ((flag & FMODELS) == DATAMODEL_ILP32) {
3020 3021                          if (copyin(from, &strioc32, sizeof (strioc32)))
3021 3022                                  return (EFAULT);
3022 3023  
3023 3024                          striocp = (struct strioctl *)to;
3024 3025                          striocp->ic_cmd = strioc32.ic_cmd;
3025 3026                          striocp->ic_timout = strioc32.ic_timout;
3026 3027                          striocp->ic_len = strioc32.ic_len;
3027 3028                          striocp->ic_dp  = (char *)(uintptr_t)strioc32.ic_dp;
3028 3029  
3029 3030                  } else { /* NATIVE data model */
3030 3031                          if (copyin(from, to, sizeof (struct strioctl))) {
3031 3032                                  return (EFAULT);
3032 3033                          } else {
3033 3034                                  return (0);
3034 3035                          }
3035 3036                  }
3036 3037          } else {
3037 3038                  ASSERT(copyflag & K_TO_K);
3038 3039                  bcopy(from, to, sizeof (struct strioctl));
3039 3040          }
3040 3041          return (0);
3041 3042  }
3042 3043  
3043 3044  static int
3044 3045  strcopyout_strioctl(void *from, void *to, int flag, int copyflag)
3045 3046  {
3046 3047          struct  strioctl32 strioc32;
3047 3048          struct  strioctl *striocp;
3048 3049  
3049 3050          if (copyflag & U_TO_K) {
3050 3051                  ASSERT((copyflag & K_TO_K) == 0);
3051 3052  
3052 3053                  if ((flag & FMODELS) == DATAMODEL_ILP32) {
3053 3054                          striocp = (struct strioctl *)from;
3054 3055                          strioc32.ic_cmd = striocp->ic_cmd;
3055 3056                          strioc32.ic_timout = striocp->ic_timout;
3056 3057                          strioc32.ic_len = striocp->ic_len;
3057 3058                          strioc32.ic_dp  = (caddr32_t)(uintptr_t)striocp->ic_dp;
3058 3059                          ASSERT((char *)(uintptr_t)strioc32.ic_dp ==
3059 3060                              striocp->ic_dp);
3060 3061  
3061 3062                          if (copyout(&strioc32, to, sizeof (strioc32)))
3062 3063                                  return (EFAULT);
3063 3064  
3064 3065                  } else { /* NATIVE data model */
3065 3066                          if (copyout(from, to, sizeof (struct strioctl))) {
3066 3067                                  return (EFAULT);
3067 3068                          } else {
3068 3069                                  return (0);
3069 3070                          }
3070 3071                  }
3071 3072          } else {
3072 3073                  ASSERT(copyflag & K_TO_K);
3073 3074                  bcopy(from, to, sizeof (struct strioctl));
3074 3075          }
3075 3076          return (0);
3076 3077  }
3077 3078  
3078 3079  #else   /* ! _LP64 */
3079 3080  
3080 3081  /* ARGSUSED2 */
3081 3082  static int
3082 3083  strcopyin_strioctl(void *from, void *to, int flag, int copyflag)
3083 3084  {
3084 3085          return (strcopyin(from, to, sizeof (struct strioctl), copyflag));
3085 3086  }
3086 3087  
3087 3088  /* ARGSUSED2 */
3088 3089  static int
3089 3090  strcopyout_strioctl(void *from, void *to, int flag, int copyflag)
3090 3091  {
3091 3092          return (strcopyout(from, to, sizeof (struct strioctl), copyflag));
3092 3093  }
3093 3094  
3094 3095  #endif  /* _LP64 */
3095 3096  
3096 3097  /*
3097 3098   * Determine type of job control semantics expected by user.  The
3098 3099   * possibilities are:
3099 3100   *      JCREAD  - Behaves like read() on fd; send SIGTTIN
3100 3101   *      JCWRITE - Behaves like write() on fd; send SIGTTOU if TOSTOP set
3101 3102   *      JCSETP  - Sets a value in the stream; send SIGTTOU, ignore TOSTOP
3102 3103   *      JCGETP  - Gets a value in the stream; no signals.
3103 3104   * See straccess in strsubr.c for usage of these values.
3104 3105   *
3105 3106   * This routine also returns -1 for I_STR as a special case; the
3106 3107   * caller must call again with the real ioctl number for
3107 3108   * classification.
3108 3109   */
3109 3110  static int
3110 3111  job_control_type(int cmd)
3111 3112  {
3112 3113          switch (cmd) {
3113 3114          case I_STR:
3114 3115                  return (-1);
3115 3116  
3116 3117          case I_RECVFD:
3117 3118          case I_E_RECVFD:
3118 3119                  return (JCREAD);
3119 3120  
3120 3121          case I_FDINSERT:
3121 3122          case I_SENDFD:
3122 3123                  return (JCWRITE);
3123 3124  
3124 3125          case TCSETA:
3125 3126          case TCSETAW:
3126 3127          case TCSETAF:
3127 3128          case TCSBRK:
3128 3129          case TCXONC:
3129 3130          case TCFLSH:
3130 3131          case TCDSET:    /* Obsolete */
3131 3132          case TIOCSWINSZ:
3132 3133          case TCSETS:
3133 3134          case TCSETSW:
3134 3135          case TCSETSF:
3135 3136          case TIOCSETD:
3136 3137          case TIOCHPCL:
3137 3138          case TIOCSETP:
3138 3139          case TIOCSETN:
3139 3140          case TIOCEXCL:
3140 3141          case TIOCNXCL:
3141 3142          case TIOCFLUSH:
3142 3143          case TIOCSETC:
3143 3144          case TIOCLBIS:
3144 3145          case TIOCLBIC:
3145 3146          case TIOCLSET:
3146 3147          case TIOCSBRK:
3147 3148          case TIOCCBRK:
3148 3149          case TIOCSDTR:
3149 3150          case TIOCCDTR:
3150 3151          case TIOCSLTC:
3151 3152          case TIOCSTOP:
3152 3153          case TIOCSTART:
3153 3154          case TIOCSTI:
3154 3155          case TIOCSPGRP:
3155 3156          case TIOCMSET:
3156 3157          case TIOCMBIS:
3157 3158          case TIOCMBIC:
3158 3159          case TIOCREMOTE:
3159 3160          case TIOCSIGNAL:
3160 3161          case LDSETT:
3161 3162          case LDSMAP:    /* Obsolete */
3162 3163          case DIOCSETP:
3163 3164          case I_FLUSH:
3164 3165          case I_SRDOPT:
3165 3166          case I_SETSIG:
3166 3167          case I_SWROPT:
3167 3168          case I_FLUSHBAND:
3168 3169          case I_SETCLTIME:
3169 3170          case I_SERROPT:
3170 3171          case I_ESETSIG:
3171 3172          case FIONBIO:
3172 3173          case FIOASYNC:
3173 3174          case FIOSETOWN:
3174 3175          case JBOOT:     /* Obsolete */
3175 3176          case JTERM:     /* Obsolete */
3176 3177          case JTIMOM:    /* Obsolete */
3177 3178          case JZOMBOOT:  /* Obsolete */
3178 3179          case JAGENT:    /* Obsolete */
3179 3180          case JTRUN:     /* Obsolete */
3180 3181          case JXTPROTO:  /* Obsolete */
3181 3182                  return (JCSETP);
3182 3183          }
3183 3184  
3184 3185          return (JCGETP);
3185 3186  }
3186 3187  
3187 3188  /*
3188 3189   * ioctl for streams
3189 3190   */
3190 3191  int
3191 3192  strioctl(struct vnode *vp, int cmd, intptr_t arg, int flag, int copyflag,
3192 3193      cred_t *crp, int *rvalp)
3193 3194  {
3194 3195          struct stdata *stp;
3195 3196          struct strcmd *scp;
3196 3197          struct strioctl strioc;
3197 3198          struct uio uio;
3198 3199          struct iovec iov;
3199 3200          int access;
3200 3201          mblk_t *mp;
3201 3202          int error = 0;
3202 3203          int done = 0;
3203 3204          ssize_t rmin, rmax;
3204 3205          queue_t *wrq;
3205 3206          queue_t *rdq;
3206 3207          boolean_t kioctl = B_FALSE;
3207 3208          uint32_t auditing = AU_AUDITING();
3208 3209  
3209 3210          if (flag & FKIOCTL) {
3210 3211                  copyflag = K_TO_K;
3211 3212                  kioctl = B_TRUE;
3212 3213          }
3213 3214          ASSERT(vp->v_stream);
3214 3215          ASSERT(copyflag == U_TO_K || copyflag == K_TO_K);
3215 3216          stp = vp->v_stream;
3216 3217  
3217 3218          TRACE_3(TR_FAC_STREAMS_FR, TR_IOCTL_ENTER,
3218 3219              "strioctl:stp %p cmd %X arg %lX", stp, cmd, arg);
3219 3220  
3220 3221          /*
3221 3222           * If the copy is kernel to kernel, make sure that the FNATIVE
3222 3223           * flag is set.  After this it would be a serious error to have
3223 3224           * no model flag.
3224 3225           */
3225 3226          if (copyflag == K_TO_K)
3226 3227                  flag = (flag & ~FMODELS) | FNATIVE;
3227 3228  
3228 3229          ASSERT((flag & FMODELS) != 0);
3229 3230  
3230 3231          wrq = stp->sd_wrq;
3231 3232          rdq = _RD(wrq);
3232 3233  
3233 3234          access = job_control_type(cmd);
3234 3235  
3235 3236          /* We should never see these here, should be handled by iwscn */
3236 3237          if (cmd == SRIOCSREDIR || cmd == SRIOCISREDIR)
3237 3238                  return (EINVAL);
3238 3239  
3239 3240          mutex_enter(&stp->sd_lock);
3240 3241          if ((access != -1) && ((error = i_straccess(stp, access)) != 0)) {
3241 3242                  mutex_exit(&stp->sd_lock);
3242 3243                  return (error);
3243 3244          }
3244 3245          mutex_exit(&stp->sd_lock);
3245 3246  
3246 3247          /*
3247 3248           * Check for sgttyb-related ioctls first, and complain as
3248 3249           * necessary.
3249 3250           */
3250 3251          switch (cmd) {
3251 3252          case TIOCGETP:
3252 3253          case TIOCSETP:
3253 3254          case TIOCSETN:
3254 3255                  if (sgttyb_handling >= 2 && !sgttyb_complaint) {
3255 3256                          sgttyb_complaint = B_TRUE;
3256 3257                          cmn_err(CE_NOTE,
3257 3258                              "application used obsolete TIOC[GS]ET");
3258 3259                  }
3259 3260                  if (sgttyb_handling >= 3) {
3260 3261                          tsignal(curthread, SIGSYS);
3261 3262                          return (EIO);
3262 3263                  }
3263 3264                  break;
3264 3265          }
3265 3266  
3266 3267          mutex_enter(&stp->sd_lock);
3267 3268  
3268 3269          switch (cmd) {
3269 3270          case I_RECVFD:
3270 3271          case I_E_RECVFD:
3271 3272          case I_PEEK:
3272 3273          case I_NREAD:
3273 3274          case FIONREAD:
3274 3275          case FIORDCHK:
3275 3276          case I_ATMARK:
3276 3277          case FIONBIO:
3277 3278          case FIOASYNC:
3278 3279                  if (stp->sd_flag & (STRDERR|STPLEX)) {
3279 3280                          error = strgeterr(stp, STRDERR|STPLEX, 0);
3280 3281                          if (error != 0) {
3281 3282                                  mutex_exit(&stp->sd_lock);
3282 3283                                  return (error);
3283 3284                          }
3284 3285                  }
3285 3286                  break;
3286 3287  
3287 3288          default:
3288 3289                  if (stp->sd_flag & (STRDERR|STWRERR|STPLEX)) {
3289 3290                          error = strgeterr(stp, STRDERR|STWRERR|STPLEX, 0);
3290 3291                          if (error != 0) {
3291 3292                                  mutex_exit(&stp->sd_lock);
3292 3293                                  return (error);
3293 3294                          }
3294 3295                  }
3295 3296          }
3296 3297  
3297 3298          mutex_exit(&stp->sd_lock);
3298 3299  
3299 3300          switch (cmd) {
3300 3301          default:
3301 3302                  /*
3302 3303                   * The stream head has hardcoded knowledge of a
3303 3304                   * miscellaneous collection of terminal-, keyboard- and
3304 3305                   * mouse-related ioctls, enumerated below.  This hardcoded
3305 3306                   * knowledge allows the stream head to automatically
3306 3307                   * convert transparent ioctl requests made by userland
3307 3308                   * programs into I_STR ioctls which many old STREAMS
3308 3309                   * modules and drivers require.
3309 3310                   *
3310 3311                   * No new ioctls should ever be added to this list.
3311 3312                   * Instead, the STREAMS module or driver should be written
3312 3313                   * to either handle transparent ioctls or require any
3313 3314                   * userland programs to use I_STR ioctls (by returning
3314 3315                   * EINVAL to any transparent ioctl requests).
3315 3316                   *
3316 3317                   * More importantly, removing ioctls from this list should
3317 3318                   * be done with the utmost care, since our STREAMS modules
3318 3319                   * and drivers *count* on the stream head performing this
3319 3320                   * conversion, and thus may panic while processing
3320 3321                   * transparent ioctl request for one of these ioctls (keep
3321 3322                   * in mind that third party modules and drivers may have
3322 3323                   * similar problems).
3323 3324                   */
3324 3325                  if (((cmd & IOCTYPE) == LDIOC) ||
3325 3326                      ((cmd & IOCTYPE) == tIOC) ||
3326 3327                      ((cmd & IOCTYPE) == TIOC) ||
3327 3328                      ((cmd & IOCTYPE) == KIOC) ||
3328 3329                      ((cmd & IOCTYPE) == MSIOC) ||
3329 3330                      ((cmd & IOCTYPE) == VUIOC)) {
3330 3331                          /*
3331 3332                           * The ioctl is a tty ioctl - set up strioc buffer
3332 3333                           * and call strdoioctl() to do the work.
3333 3334                           */
3334 3335                          if (stp->sd_flag & STRHUP)
3335 3336                                  return (ENXIO);
3336 3337                          strioc.ic_cmd = cmd;
3337 3338                          strioc.ic_timout = INFTIM;
3338 3339  
3339 3340                          switch (cmd) {
3340 3341  
3341 3342                          case TCXONC:
3342 3343                          case TCSBRK:
3343 3344                          case TCFLSH:
3344 3345                          case TCDSET:
3345 3346                                  {
3346 3347                                  int native_arg = (int)arg;
3347 3348                                  strioc.ic_len = sizeof (int);
3348 3349                                  strioc.ic_dp = (char *)&native_arg;
3349 3350                                  return (strdoioctl(stp, &strioc, flag,
3350 3351                                      K_TO_K, crp, rvalp));
3351 3352                                  }
3352 3353  
3353 3354                          case TCSETA:
3354 3355                          case TCSETAW:
3355 3356                          case TCSETAF:
3356 3357                                  strioc.ic_len = sizeof (struct termio);
3357 3358                                  strioc.ic_dp = (char *)arg;
3358 3359                                  return (strdoioctl(stp, &strioc, flag,
3359 3360                                      copyflag, crp, rvalp));
3360 3361  
3361 3362                          case TCSETS:
3362 3363                          case TCSETSW:
3363 3364                          case TCSETSF:
3364 3365                                  strioc.ic_len = sizeof (struct termios);
3365 3366                                  strioc.ic_dp = (char *)arg;
3366 3367                                  return (strdoioctl(stp, &strioc, flag,
3367 3368                                      copyflag, crp, rvalp));
3368 3369  
3369 3370                          case LDSETT:
3370 3371                                  strioc.ic_len = sizeof (struct termcb);
3371 3372                                  strioc.ic_dp = (char *)arg;
3372 3373                                  return (strdoioctl(stp, &strioc, flag,
3373 3374                                      copyflag, crp, rvalp));
3374 3375  
3375 3376                          case TIOCSETP:
3376 3377                                  strioc.ic_len = sizeof (struct sgttyb);
3377 3378                                  strioc.ic_dp = (char *)arg;
3378 3379                                  return (strdoioctl(stp, &strioc, flag,
3379 3380                                      copyflag, crp, rvalp));
3380 3381  
3381 3382                          case TIOCSTI:
3382 3383                                  if ((flag & FREAD) == 0 &&
3383 3384                                      secpolicy_sti(crp) != 0) {
3384 3385                                          return (EPERM);
3385 3386                                  }
3386 3387                                  mutex_enter(&stp->sd_lock);
3387 3388                                  mutex_enter(&curproc->p_splock);
3388 3389                                  if (stp->sd_sidp != curproc->p_sessp->s_sidp &&
3389 3390                                      secpolicy_sti(crp) != 0) {
3390 3391                                          mutex_exit(&curproc->p_splock);
3391 3392                                          mutex_exit(&stp->sd_lock);
3392 3393                                          return (EACCES);
3393 3394                                  }
3394 3395                                  mutex_exit(&curproc->p_splock);
3395 3396                                  mutex_exit(&stp->sd_lock);
3396 3397  
3397 3398                                  strioc.ic_len = sizeof (char);
3398 3399                                  strioc.ic_dp = (char *)arg;
3399 3400                                  return (strdoioctl(stp, &strioc, flag,
3400 3401                                      copyflag, crp, rvalp));
3401 3402  
3402 3403                          case TIOCSWINSZ:
3403 3404                                  strioc.ic_len = sizeof (struct winsize);
3404 3405                                  strioc.ic_dp = (char *)arg;
3405 3406                                  return (strdoioctl(stp, &strioc, flag,
3406 3407                                      copyflag, crp, rvalp));
3407 3408  
3408 3409                          case TIOCSSIZE:
3409 3410                                  strioc.ic_len = sizeof (struct ttysize);
3410 3411                                  strioc.ic_dp = (char *)arg;
3411 3412                                  return (strdoioctl(stp, &strioc, flag,
3412 3413                                      copyflag, crp, rvalp));
3413 3414  
3414 3415                          case TIOCSSOFTCAR:
3415 3416                          case KIOCTRANS:
3416 3417                          case KIOCTRANSABLE:
3417 3418                          case KIOCCMD:
3418 3419                          case KIOCSDIRECT:
3419 3420                          case KIOCSCOMPAT:
3420 3421                          case KIOCSKABORTEN:
3421 3422                          case KIOCSRPTDELAY:
3422 3423                          case KIOCSRPTRATE:
3423 3424                          case VUIDSFORMAT:
3424 3425                          case TIOCSPPS:
3425 3426                                  strioc.ic_len = sizeof (int);
3426 3427                                  strioc.ic_dp = (char *)arg;
3427 3428                                  return (strdoioctl(stp, &strioc, flag,
3428 3429                                      copyflag, crp, rvalp));
3429 3430  
3430 3431                          case KIOCSETKEY:
3431 3432                          case KIOCGETKEY:
3432 3433                                  strioc.ic_len = sizeof (struct kiockey);
3433 3434                                  strioc.ic_dp = (char *)arg;
3434 3435                                  return (strdoioctl(stp, &strioc, flag,
3435 3436                                      copyflag, crp, rvalp));
3436 3437  
3437 3438                          case KIOCSKEY:
3438 3439                          case KIOCGKEY:
3439 3440                                  strioc.ic_len = sizeof (struct kiockeymap);
3440 3441                                  strioc.ic_dp = (char *)arg;
3441 3442                                  return (strdoioctl(stp, &strioc, flag,
3442 3443                                      copyflag, crp, rvalp));
3443 3444  
3444 3445                          case KIOCSLED:
3445 3446                                  /* arg is a pointer to char */
3446 3447                                  strioc.ic_len = sizeof (char);
3447 3448                                  strioc.ic_dp = (char *)arg;
3448 3449                                  return (strdoioctl(stp, &strioc, flag,
3449 3450                                      copyflag, crp, rvalp));
3450 3451  
3451 3452                          case MSIOSETPARMS:
3452 3453                                  strioc.ic_len = sizeof (Ms_parms);
3453 3454                                  strioc.ic_dp = (char *)arg;
3454 3455                                  return (strdoioctl(stp, &strioc, flag,
3455 3456                                      copyflag, crp, rvalp));
3456 3457  
3457 3458                          case VUIDSADDR:
3458 3459                          case VUIDGADDR:
3459 3460                                  strioc.ic_len = sizeof (struct vuid_addr_probe);
3460 3461                                  strioc.ic_dp = (char *)arg;
3461 3462                                  return (strdoioctl(stp, &strioc, flag,
3462 3463                                      copyflag, crp, rvalp));
3463 3464  
3464 3465                          /*
3465 3466                           * These M_IOCTL's don't require any data to be sent
3466 3467                           * downstream, and the driver will allocate and link
3467 3468                           * on its own mblk_t upon M_IOCACK -- thus we set
3468 3469                           * ic_len to zero and set ic_dp to arg so we know
3469 3470                           * where to copyout to later.
3470 3471                           */
3471 3472                          case TIOCGSOFTCAR:
3472 3473                          case TIOCGWINSZ:
3473 3474                          case TIOCGSIZE:
3474 3475                          case KIOCGTRANS:
3475 3476                          case KIOCGTRANSABLE:
3476 3477                          case KIOCTYPE:
3477 3478                          case KIOCGDIRECT:
3478 3479                          case KIOCGCOMPAT:
3479 3480                          case KIOCLAYOUT:
3480 3481                          case KIOCGLED:
3481 3482                          case MSIOGETPARMS:
3482 3483                          case MSIOBUTTONS:
3483 3484                          case VUIDGFORMAT:
3484 3485                          case TIOCGPPS:
3485 3486                          case TIOCGPPSEV:
3486 3487                          case TCGETA:
3487 3488                          case TCGETS:
3488 3489                          case LDGETT:
3489 3490                          case TIOCGETP:
3490 3491                          case KIOCGRPTDELAY:
3491 3492                          case KIOCGRPTRATE:
3492 3493                                  strioc.ic_len = 0;
3493 3494                                  strioc.ic_dp = (char *)arg;
3494 3495                                  return (strdoioctl(stp, &strioc, flag,
3495 3496                                      copyflag, crp, rvalp));
3496 3497                          }
3497 3498                  }
3498 3499  
3499 3500                  /*
3500 3501                   * Unknown cmd - send it down as a transparent ioctl.
3501 3502                   */
3502 3503                  strioc.ic_cmd = cmd;
3503 3504                  strioc.ic_timout = INFTIM;
3504 3505                  strioc.ic_len = TRANSPARENT;
3505 3506                  strioc.ic_dp = (char *)&arg;
3506 3507  
3507 3508                  return (strdoioctl(stp, &strioc, flag, copyflag, crp, rvalp));
3508 3509  
3509 3510          case I_STR:
3510 3511                  /*
3511 3512                   * Stream ioctl.  Read in an strioctl buffer from the user
3512 3513                   * along with any data specified and send it downstream.
3513 3514                   * Strdoioctl will wait allow only one ioctl message at
3514 3515                   * a time, and waits for the acknowledgement.
3515 3516                   */
3516 3517  
3517 3518                  if (stp->sd_flag & STRHUP)
3518 3519                          return (ENXIO);
3519 3520  
3520 3521                  error = strcopyin_strioctl((void *)arg, &strioc, flag,
3521 3522                      copyflag);
3522 3523                  if (error != 0)
3523 3524                          return (error);
3524 3525  
3525 3526                  if ((strioc.ic_len < 0) || (strioc.ic_timout < -1))
3526 3527                          return (EINVAL);
3527 3528  
3528 3529                  access = job_control_type(strioc.ic_cmd);
3529 3530                  mutex_enter(&stp->sd_lock);
3530 3531                  if ((access != -1) &&
3531 3532                      ((error = i_straccess(stp, access)) != 0)) {
3532 3533                          mutex_exit(&stp->sd_lock);
3533 3534                          return (error);
3534 3535                  }
3535 3536                  mutex_exit(&stp->sd_lock);
3536 3537  
3537 3538                  /*
3538 3539                   * The I_STR facility provides a trap door for malicious
3539 3540                   * code to send down bogus streamio(7I) ioctl commands to
3540 3541                   * unsuspecting STREAMS modules and drivers which expect to
3541 3542                   * only get these messages from the stream head.
3542 3543                   * Explicitly prohibit any streamio ioctls which can be
3543 3544                   * passed downstream by the stream head.  Note that we do
3544 3545                   * not block all streamio ioctls because the ioctl
3545 3546                   * numberspace is not well managed and thus it's possible
3546 3547                   * that a module or driver's ioctl numbers may accidentally
3547 3548                   * collide with them.
3548 3549                   */
3549 3550                  switch (strioc.ic_cmd) {
3550 3551                  case I_LINK:
3551 3552                  case I_PLINK:
3552 3553                  case I_UNLINK:
3553 3554                  case I_PUNLINK:
3554 3555                  case _I_GETPEERCRED:
3555 3556                  case _I_PLINK_LH:
3556 3557                          return (EINVAL);
3557 3558                  }
3558 3559  
3559 3560                  error = strdoioctl(stp, &strioc, flag, copyflag, crp, rvalp);
3560 3561                  if (error == 0) {
3561 3562                          error = strcopyout_strioctl(&strioc, (void *)arg,
3562 3563                              flag, copyflag);
3563 3564                  }
3564 3565                  return (error);
3565 3566  
3566 3567          case _I_CMD:
3567 3568                  /*
3568 3569                   * Like I_STR, but without using M_IOC* messages and without
3569 3570                   * copyins/copyouts beyond the passed-in argument.
3570 3571                   */
3571 3572                  if (stp->sd_flag & STRHUP)
3572 3573                          return (ENXIO);
3573 3574  
3574 3575                  if ((scp = kmem_alloc(sizeof (strcmd_t), KM_NOSLEEP)) == NULL)
3575 3576                          return (ENOMEM);
3576 3577  
3577 3578                  if (copyin((void *)arg, scp, sizeof (strcmd_t))) {
3578 3579                          kmem_free(scp, sizeof (strcmd_t));
3579 3580                          return (EFAULT);
3580 3581                  }
3581 3582  
3582 3583                  access = job_control_type(scp->sc_cmd);
3583 3584                  mutex_enter(&stp->sd_lock);
3584 3585                  if (access != -1 && (error = i_straccess(stp, access)) != 0) {
3585 3586                          mutex_exit(&stp->sd_lock);
3586 3587                          kmem_free(scp, sizeof (strcmd_t));
3587 3588                          return (error);
3588 3589                  }
3589 3590                  mutex_exit(&stp->sd_lock);
3590 3591  
3591 3592                  *rvalp = 0;
3592 3593                  if ((error = strdocmd(stp, scp, crp)) == 0) {
3593 3594                          if (copyout(scp, (void *)arg, sizeof (strcmd_t)))
3594 3595                                  error = EFAULT;
3595 3596                  }
3596 3597                  kmem_free(scp, sizeof (strcmd_t));
3597 3598                  return (error);
3598 3599  
3599 3600          case I_NREAD:
3600 3601                  /*
3601 3602                   * Return number of bytes of data in first message
3602 3603                   * in queue in "arg" and return the number of messages
3603 3604                   * in queue in return value.
3604 3605                   */
3605 3606          {
3606 3607                  size_t  size;
3607 3608                  int     retval;
3608 3609                  int     count = 0;
3609 3610  
3610 3611                  mutex_enter(QLOCK(rdq));
3611 3612  
3612 3613                  size = msgdsize(rdq->q_first);
3613 3614                  for (mp = rdq->q_first; mp != NULL; mp = mp->b_next)
3614 3615                          count++;
3615 3616  
3616 3617                  mutex_exit(QLOCK(rdq));
3617 3618                  if (stp->sd_struiordq) {
3618 3619                          infod_t infod;
3619 3620  
3620 3621                          infod.d_cmd = INFOD_COUNT;
3621 3622                          infod.d_count = 0;
3622 3623                          if (count == 0) {
3623 3624                                  infod.d_cmd |= INFOD_FIRSTBYTES;
3624 3625                                  infod.d_bytes = 0;
3625 3626                          }
3626 3627                          infod.d_res = 0;
3627 3628                          (void) infonext(rdq, &infod);
3628 3629                          count += infod.d_count;
3629 3630                          if (infod.d_res & INFOD_FIRSTBYTES)
3630 3631                                  size = infod.d_bytes;
3631 3632                  }
3632 3633  
3633 3634                  /*
3634 3635                   * Drop down from size_t to the "int" required by the
3635 3636                   * interface.  Cap at INT_MAX.
3636 3637                   */
3637 3638                  retval = MIN(size, INT_MAX);
3638 3639                  error = strcopyout(&retval, (void *)arg, sizeof (retval),
3639 3640                      copyflag);
3640 3641                  if (!error)
3641 3642                          *rvalp = count;
3642 3643                  return (error);
3643 3644          }
3644 3645  
3645 3646          case FIONREAD:
3646 3647                  /*
3647 3648                   * Return number of bytes of data in all data messages
3648 3649                   * in queue in "arg".
3649 3650                   */
3650 3651          {
3651 3652                  size_t  size = 0;
3652 3653                  int     retval;
3653 3654  
3654 3655                  mutex_enter(QLOCK(rdq));
3655 3656                  for (mp = rdq->q_first; mp != NULL; mp = mp->b_next)
3656 3657                          size += msgdsize(mp);
3657 3658                  mutex_exit(QLOCK(rdq));
3658 3659  
3659 3660                  if (stp->sd_struiordq) {
3660 3661                          infod_t infod;
3661 3662  
3662 3663                          infod.d_cmd = INFOD_BYTES;
3663 3664                          infod.d_res = 0;
3664 3665                          infod.d_bytes = 0;
3665 3666                          (void) infonext(rdq, &infod);
3666 3667                          size += infod.d_bytes;
3667 3668                  }
3668 3669  
3669 3670                  /*
3670 3671                   * Drop down from size_t to the "int" required by the
3671 3672                   * interface.  Cap at INT_MAX.
3672 3673                   */
3673 3674                  retval = MIN(size, INT_MAX);
3674 3675                  error = strcopyout(&retval, (void *)arg, sizeof (retval),
3675 3676                      copyflag);
3676 3677  
3677 3678                  *rvalp = 0;
3678 3679                  return (error);
3679 3680          }
3680 3681          case FIORDCHK:
3681 3682                  /*
3682 3683                   * FIORDCHK does not use arg value (like FIONREAD),
3683 3684                   * instead a count is returned. I_NREAD value may
3684 3685                   * not be accurate but safe. The real thing to do is
3685 3686                   * to add the msgdsizes of all data  messages until
3686 3687                   * a non-data message.
3687 3688                   */
3688 3689          {
3689 3690                  size_t size = 0;
3690 3691  
3691 3692                  mutex_enter(QLOCK(rdq));
3692 3693                  for (mp = rdq->q_first; mp != NULL; mp = mp->b_next)
3693 3694                          size += msgdsize(mp);
3694 3695                  mutex_exit(QLOCK(rdq));
3695 3696  
3696 3697                  if (stp->sd_struiordq) {
3697 3698                          infod_t infod;
3698 3699  
3699 3700                          infod.d_cmd = INFOD_BYTES;
3700 3701                          infod.d_res = 0;
3701 3702                          infod.d_bytes = 0;
3702 3703                          (void) infonext(rdq, &infod);
3703 3704                          size += infod.d_bytes;
3704 3705                  }
3705 3706  
3706 3707                  /*
3707 3708                   * Since ioctl returns an int, and memory sizes under
3708 3709                   * LP64 may not fit, we return INT_MAX if the count was
3709 3710                   * actually greater.
3710 3711                   */
3711 3712                  *rvalp = MIN(size, INT_MAX);
3712 3713                  return (0);
3713 3714          }
3714 3715  
3715 3716          case I_FIND:
3716 3717                  /*
3717 3718                   * Get module name.
3718 3719                   */
3719 3720          {
3720 3721                  char mname[FMNAMESZ + 1];
3721 3722                  queue_t *q;
3722 3723  
3723 3724                  error = (copyflag & U_TO_K ? copyinstr : copystr)((void *)arg,
3724 3725                      mname, FMNAMESZ + 1, NULL);
3725 3726                  if (error)
3726 3727                          return ((error == ENAMETOOLONG) ? EINVAL : EFAULT);
3727 3728  
3728 3729                  /*
3729 3730                   * Return EINVAL if we're handed a bogus module name.
3730 3731                   */
3731 3732                  if (fmodsw_find(mname, FMODSW_LOAD) == NULL) {
3732 3733                          TRACE_0(TR_FAC_STREAMS_FR,
3733 3734                              TR_I_CANT_FIND, "couldn't I_FIND");
3734 3735                          return (EINVAL);
3735 3736                  }
3736 3737  
3737 3738                  *rvalp = 0;
3738 3739  
3739 3740                  /* Look downstream to see if module is there. */
3740 3741                  claimstr(stp->sd_wrq);
3741 3742                  for (q = stp->sd_wrq->q_next; q; q = q->q_next) {
3742 3743                          if (q->q_flag & QREADR) {
3743 3744                                  q = NULL;
3744 3745                                  break;
3745 3746                          }
3746 3747                          if (strcmp(mname, Q2NAME(q)) == 0)
3747 3748                                  break;
3748 3749                  }
3749 3750                  releasestr(stp->sd_wrq);
3750 3751  
3751 3752                  *rvalp = (q ? 1 : 0);
3752 3753                  return (error);
3753 3754          }
3754 3755  
3755 3756          case I_PUSH:
3756 3757          case __I_PUSH_NOCTTY:
3757 3758                  /*
3758 3759                   * Push a module.
3759 3760                   * For the case __I_PUSH_NOCTTY push a module but
3760 3761                   * do not allocate controlling tty. See bugid 4025044
3761 3762                   */
3762 3763  
3763 3764          {
3764 3765                  char mname[FMNAMESZ + 1];
3765 3766                  fmodsw_impl_t *fp;
3766 3767                  dev_t dummydev;
3767 3768  
3768 3769                  if (stp->sd_flag & STRHUP)
3769 3770                          return (ENXIO);
3770 3771  
3771 3772                  /*
3772 3773                   * Get module name and look up in fmodsw.
3773 3774                   */
3774 3775                  error = (copyflag & U_TO_K ? copyinstr : copystr)((void *)arg,
3775 3776                      mname, FMNAMESZ + 1, NULL);
  
    | 
      ↓ open down ↓ | 
    3738 lines elided | 
    
      ↑ open up ↑ | 
  
3776 3777                  if (error)
3777 3778                          return ((error == ENAMETOOLONG) ? EINVAL : EFAULT);
3778 3779  
3779 3780                  if ((fp = fmodsw_find(mname, FMODSW_HOLD | FMODSW_LOAD)) ==
3780 3781                      NULL)
3781 3782                          return (EINVAL);
3782 3783  
3783 3784                  TRACE_2(TR_FAC_STREAMS_FR, TR_I_PUSH,
3784 3785                      "I_PUSH:fp %p stp %p", fp, stp);
3785 3786  
     3787 +                /*
     3788 +                 * If the module is flagged as single-instance, then check
     3789 +                 * to see if the module is already pushed. If it is, return
     3790 +                 * as if the push was successful.
     3791 +                 */
     3792 +                if (fp->f_qflag & _QSINGLE_INSTANCE) {
     3793 +                        queue_t *q;
     3794 +
     3795 +                        claimstr(stp->sd_wrq);
     3796 +                        for (q = stp->sd_wrq->q_next; q; q = q->q_next) {
     3797 +                                if (q->q_flag & QREADR) {
     3798 +                                        q = NULL;
     3799 +                                        break;
     3800 +                                }
     3801 +                                if (strcmp(mname, Q2NAME(q)) == 0)
     3802 +                                        break;
     3803 +                        }
     3804 +                        releasestr(stp->sd_wrq);
     3805 +                        if (q != NULL) {
     3806 +                                fmodsw_rele(fp);
     3807 +                                return (0);
     3808 +                        }
     3809 +                }
     3810 +
3786 3811                  if (error = strstartplumb(stp, flag, cmd)) {
3787 3812                          fmodsw_rele(fp);
3788 3813                          return (error);
3789 3814                  }
3790 3815  
3791 3816                  /*
3792 3817                   * See if any more modules can be pushed on this stream.
3793 3818                   * Note that this check must be done after strstartplumb()
3794 3819                   * since otherwise multiple threads issuing I_PUSHes on
3795 3820                   * the same stream will be able to exceed nstrpush.
3796 3821                   */
3797 3822                  mutex_enter(&stp->sd_lock);
3798 3823                  if (stp->sd_pushcnt >= nstrpush) {
3799 3824                          fmodsw_rele(fp);
3800 3825                          strendplumb(stp);
3801 3826                          mutex_exit(&stp->sd_lock);
3802 3827                          return (EINVAL);
3803 3828                  }
3804 3829                  mutex_exit(&stp->sd_lock);
3805 3830  
3806 3831                  /*
3807 3832                   * Push new module and call its open routine
3808 3833                   * via qattach().  Modules don't change device
3809 3834                   * numbers, so just ignore dummydev here.
3810 3835                   */
3811 3836                  dummydev = vp->v_rdev;
3812 3837                  if ((error = qattach(rdq, &dummydev, 0, crp, fp,
3813 3838                      B_FALSE)) == 0) {
3814 3839                          if (vp->v_type == VCHR && /* sorry, no pipes allowed */
3815 3840                              (cmd == I_PUSH) && (stp->sd_flag & STRISTTY)) {
3816 3841                                  /*
3817 3842                                   * try to allocate it as a controlling terminal
3818 3843                                   */
3819 3844                                  (void) strctty(stp);
3820 3845                          }
3821 3846                  }
3822 3847  
3823 3848                  mutex_enter(&stp->sd_lock);
3824 3849  
3825 3850                  /*
3826 3851                   * As a performance concern we are caching the values of
3827 3852                   * q_minpsz and q_maxpsz of the module below the stream
3828 3853                   * head in the stream head.
3829 3854                   */
3830 3855                  mutex_enter(QLOCK(stp->sd_wrq->q_next));
3831 3856                  rmin = stp->sd_wrq->q_next->q_minpsz;
3832 3857                  rmax = stp->sd_wrq->q_next->q_maxpsz;
3833 3858                  mutex_exit(QLOCK(stp->sd_wrq->q_next));
3834 3859  
3835 3860                  /* Do this processing here as a performance concern */
3836 3861                  if (strmsgsz != 0) {
3837 3862                          if (rmax == INFPSZ)
3838 3863                                  rmax = strmsgsz;
3839 3864                          else  {
3840 3865                                  if (vp->v_type == VFIFO)
3841 3866                                          rmax = MIN(PIPE_BUF, rmax);
3842 3867                                  else    rmax = MIN(strmsgsz, rmax);
3843 3868                          }
3844 3869                  }
3845 3870  
3846 3871                  mutex_enter(QLOCK(wrq));
3847 3872                  stp->sd_qn_minpsz = rmin;
3848 3873                  stp->sd_qn_maxpsz = rmax;
3849 3874                  mutex_exit(QLOCK(wrq));
3850 3875  
3851 3876                  strendplumb(stp);
3852 3877                  mutex_exit(&stp->sd_lock);
3853 3878                  return (error);
3854 3879          }
3855 3880  
3856 3881          case I_POP:
3857 3882          {
3858 3883                  queue_t *q;
3859 3884  
3860 3885                  if (stp->sd_flag & STRHUP)
3861 3886                          return (ENXIO);
3862 3887                  if (!wrq->q_next)       /* for broken pipes */
3863 3888                          return (EINVAL);
3864 3889  
3865 3890                  if (error = strstartplumb(stp, flag, cmd))
3866 3891                          return (error);
3867 3892  
3868 3893                  /*
3869 3894                   * If there is an anchor on this stream and popping
3870 3895                   * the current module would attempt to pop through the
3871 3896                   * anchor, then disallow the pop unless we have sufficient
3872 3897                   * privileges; take the cheapest (non-locking) check
3873 3898                   * first.
3874 3899                   */
3875 3900                  if (secpolicy_ip_config(crp, B_TRUE) != 0 ||
3876 3901                      (stp->sd_anchorzone != crgetzoneid(crp))) {
3877 3902                          mutex_enter(&stp->sd_lock);
3878 3903                          /*
3879 3904                           * Anchors only apply if there's at least one
3880 3905                           * module on the stream (sd_pushcnt > 0).
3881 3906                           */
3882 3907                          if (stp->sd_pushcnt > 0 &&
3883 3908                              stp->sd_pushcnt == stp->sd_anchor &&
3884 3909                              stp->sd_vnode->v_type != VFIFO) {
3885 3910                                  strendplumb(stp);
3886 3911                                  mutex_exit(&stp->sd_lock);
3887 3912                                  if (stp->sd_anchorzone != crgetzoneid(crp))
3888 3913                                          return (EINVAL);
3889 3914                                  /* Audit and report error */
3890 3915                                  return (secpolicy_ip_config(crp, B_FALSE));
3891 3916                          }
3892 3917                          mutex_exit(&stp->sd_lock);
3893 3918                  }
3894 3919  
3895 3920                  q = wrq->q_next;
3896 3921                  TRACE_2(TR_FAC_STREAMS_FR, TR_I_POP,
3897 3922                      "I_POP:%p from %p", q, stp);
3898 3923                  if (q->q_next == NULL || (q->q_flag & (QREADR|QISDRV))) {
3899 3924                          error = EINVAL;
3900 3925                  } else {
3901 3926                          qdetach(_RD(q), 1, flag, crp, B_FALSE);
3902 3927                          error = 0;
3903 3928                  }
3904 3929                  mutex_enter(&stp->sd_lock);
3905 3930  
3906 3931                  /*
3907 3932                   * As a performance concern we are caching the values of
3908 3933                   * q_minpsz and q_maxpsz of the module below the stream
3909 3934                   * head in the stream head.
3910 3935                   */
3911 3936                  mutex_enter(QLOCK(wrq->q_next));
3912 3937                  rmin = wrq->q_next->q_minpsz;
3913 3938                  rmax = wrq->q_next->q_maxpsz;
3914 3939                  mutex_exit(QLOCK(wrq->q_next));
3915 3940  
3916 3941                  /* Do this processing here as a performance concern */
3917 3942                  if (strmsgsz != 0) {
3918 3943                          if (rmax == INFPSZ)
3919 3944                                  rmax = strmsgsz;
3920 3945                          else  {
3921 3946                                  if (vp->v_type == VFIFO)
3922 3947                                          rmax = MIN(PIPE_BUF, rmax);
3923 3948                                  else    rmax = MIN(strmsgsz, rmax);
3924 3949                          }
3925 3950                  }
3926 3951  
3927 3952                  mutex_enter(QLOCK(wrq));
3928 3953                  stp->sd_qn_minpsz = rmin;
3929 3954                  stp->sd_qn_maxpsz = rmax;
3930 3955                  mutex_exit(QLOCK(wrq));
3931 3956  
3932 3957                  /* If we popped through the anchor, then reset the anchor. */
3933 3958                  if (stp->sd_pushcnt < stp->sd_anchor) {
3934 3959                          stp->sd_anchor = 0;
3935 3960                          stp->sd_anchorzone = 0;
3936 3961                  }
3937 3962                  strendplumb(stp);
3938 3963                  mutex_exit(&stp->sd_lock);
3939 3964                  return (error);
3940 3965          }
3941 3966  
3942 3967          case _I_MUXID2FD:
3943 3968          {
3944 3969                  /*
3945 3970                   * Create a fd for a I_PLINK'ed lower stream with a given
3946 3971                   * muxid.  With the fd, application can send down ioctls,
3947 3972                   * like I_LIST, to the previously I_PLINK'ed stream.  Note
3948 3973                   * that after getting the fd, the application has to do an
3949 3974                   * I_PUNLINK on the muxid before it can do any operation
3950 3975                   * on the lower stream.  This is required by spec1170.
3951 3976                   *
3952 3977                   * The fd used to do this ioctl should point to the same
3953 3978                   * controlling device used to do the I_PLINK.  If it uses
3954 3979                   * a different stream or an invalid muxid, I_MUXID2FD will
3955 3980                   * fail.  The error code is set to EINVAL.
3956 3981                   *
3957 3982                   * The intended use of this interface is the following.
3958 3983                   * An application I_PLINK'ed a stream and exits.  The fd
3959 3984                   * to the lower stream is gone.  Another application
3960 3985                   * wants to get a fd to the lower stream, it uses I_MUXID2FD.
3961 3986                   */
3962 3987                  int muxid = (int)arg;
3963 3988                  int fd;
3964 3989                  linkinfo_t *linkp;
3965 3990                  struct file *fp;
3966 3991                  netstack_t *ns;
3967 3992                  str_stack_t *ss;
3968 3993  
3969 3994                  /*
3970 3995                   * Do not allow the wildcard muxid.  This ioctl is not
3971 3996                   * intended to find arbitrary link.
3972 3997                   */
3973 3998                  if (muxid == 0) {
3974 3999                          return (EINVAL);
3975 4000                  }
3976 4001  
3977 4002                  ns = netstack_find_by_cred(crp);
3978 4003                  ASSERT(ns != NULL);
3979 4004                  ss = ns->netstack_str;
3980 4005                  ASSERT(ss != NULL);
3981 4006  
3982 4007                  mutex_enter(&muxifier);
3983 4008                  linkp = findlinks(vp->v_stream, muxid, LINKPERSIST, ss);
3984 4009                  if (linkp == NULL) {
3985 4010                          mutex_exit(&muxifier);
3986 4011                          netstack_rele(ss->ss_netstack);
3987 4012                          return (EINVAL);
3988 4013                  }
3989 4014  
3990 4015                  if ((fd = ufalloc(0)) == -1) {
3991 4016                          mutex_exit(&muxifier);
3992 4017                          netstack_rele(ss->ss_netstack);
3993 4018                          return (EMFILE);
3994 4019                  }
3995 4020                  fp = linkp->li_fpdown;
3996 4021                  mutex_enter(&fp->f_tlock);
3997 4022                  fp->f_count++;
3998 4023                  mutex_exit(&fp->f_tlock);
3999 4024                  mutex_exit(&muxifier);
4000 4025                  setf(fd, fp);
4001 4026                  *rvalp = fd;
4002 4027                  netstack_rele(ss->ss_netstack);
4003 4028                  return (0);
4004 4029          }
4005 4030  
4006 4031          case _I_INSERT:
4007 4032          {
4008 4033                  /*
4009 4034                   * To insert a module to a given position in a stream.
4010 4035                   * In the first release, only allow privileged user
4011 4036                   * to use this ioctl. Furthermore, the insert is only allowed
4012 4037                   * below an anchor if the zoneid is the same as the zoneid
4013 4038                   * which created the anchor.
4014 4039                   *
4015 4040                   * Note that we do not plan to support this ioctl
4016 4041                   * on pipes in the first release.  We want to learn more
4017 4042                   * about the implications of these ioctls before extending
4018 4043                   * their support.  And we do not think these features are
4019 4044                   * valuable for pipes.
4020 4045                   */
4021 4046                  STRUCT_DECL(strmodconf, strmodinsert);
4022 4047                  char mod_name[FMNAMESZ + 1];
4023 4048                  fmodsw_impl_t *fp;
4024 4049                  dev_t dummydev;
4025 4050                  queue_t *tmp_wrq;
4026 4051                  int pos;
4027 4052                  boolean_t is_insert;
4028 4053  
4029 4054                  STRUCT_INIT(strmodinsert, flag);
4030 4055                  if (stp->sd_flag & STRHUP)
4031 4056                          return (ENXIO);
4032 4057                  if (STRMATED(stp))
4033 4058                          return (EINVAL);
4034 4059                  if ((error = secpolicy_net_config(crp, B_FALSE)) != 0)
4035 4060                          return (error);
4036 4061                  if (stp->sd_anchor != 0 &&
4037 4062                      stp->sd_anchorzone != crgetzoneid(crp))
4038 4063                          return (EINVAL);
4039 4064  
4040 4065                  error = strcopyin((void *)arg, STRUCT_BUF(strmodinsert),
4041 4066                      STRUCT_SIZE(strmodinsert), copyflag);
4042 4067                  if (error)
4043 4068                          return (error);
4044 4069  
4045 4070                  /*
4046 4071                   * Get module name and look up in fmodsw.
4047 4072                   */
4048 4073                  error = (copyflag & U_TO_K ? copyinstr :
4049 4074                      copystr)(STRUCT_FGETP(strmodinsert, mod_name),
4050 4075                      mod_name, FMNAMESZ + 1, NULL);
4051 4076                  if (error)
4052 4077                          return ((error == ENAMETOOLONG) ? EINVAL : EFAULT);
4053 4078  
4054 4079                  if ((fp = fmodsw_find(mod_name, FMODSW_HOLD | FMODSW_LOAD)) ==
4055 4080                      NULL)
4056 4081                          return (EINVAL);
4057 4082  
4058 4083                  if (error = strstartplumb(stp, flag, cmd)) {
4059 4084                          fmodsw_rele(fp);
4060 4085                          return (error);
4061 4086                  }
4062 4087  
4063 4088                  /*
4064 4089                   * Is this _I_INSERT just like an I_PUSH?  We need to know
4065 4090                   * this because we do some optimizations if this is a
4066 4091                   * module being pushed.
4067 4092                   */
4068 4093                  pos = STRUCT_FGET(strmodinsert, pos);
4069 4094                  is_insert = (pos != 0);
4070 4095  
4071 4096                  /*
4072 4097                   * Make sure pos is valid.  Even though it is not an I_PUSH,
4073 4098                   * we impose the same limit on the number of modules in a
4074 4099                   * stream.
4075 4100                   */
4076 4101                  mutex_enter(&stp->sd_lock);
4077 4102                  if (stp->sd_pushcnt >= nstrpush || pos < 0 ||
4078 4103                      pos > stp->sd_pushcnt) {
4079 4104                          fmodsw_rele(fp);
4080 4105                          strendplumb(stp);
4081 4106                          mutex_exit(&stp->sd_lock);
4082 4107                          return (EINVAL);
4083 4108                  }
4084 4109                  if (stp->sd_anchor != 0) {
4085 4110                          /*
4086 4111                           * Is this insert below the anchor?
4087 4112                           * Pushcnt hasn't been increased yet hence
4088 4113                           * we test for greater than here, and greater or
4089 4114                           * equal after qattach.
4090 4115                           */
4091 4116                          if (pos > (stp->sd_pushcnt - stp->sd_anchor) &&
4092 4117                              stp->sd_anchorzone != crgetzoneid(crp)) {
4093 4118                                  fmodsw_rele(fp);
4094 4119                                  strendplumb(stp);
4095 4120                                  mutex_exit(&stp->sd_lock);
4096 4121                                  return (EPERM);
4097 4122                          }
4098 4123                  }
4099 4124  
4100 4125                  mutex_exit(&stp->sd_lock);
4101 4126  
4102 4127                  /*
4103 4128                   * First find the correct position this module to
4104 4129                   * be inserted.  We don't need to call claimstr()
4105 4130                   * as the stream should not be changing at this point.
4106 4131                   *
4107 4132                   * Insert new module and call its open routine
4108 4133                   * via qattach().  Modules don't change device
4109 4134                   * numbers, so just ignore dummydev here.
4110 4135                   */
4111 4136                  for (tmp_wrq = stp->sd_wrq; pos > 0;
4112 4137                      tmp_wrq = tmp_wrq->q_next, pos--) {
4113 4138                          ASSERT(SAMESTR(tmp_wrq));
4114 4139                  }
4115 4140                  dummydev = vp->v_rdev;
4116 4141                  if ((error = qattach(_RD(tmp_wrq), &dummydev, 0, crp,
4117 4142                      fp, is_insert)) != 0) {
4118 4143                          mutex_enter(&stp->sd_lock);
4119 4144                          strendplumb(stp);
4120 4145                          mutex_exit(&stp->sd_lock);
4121 4146                          return (error);
4122 4147                  }
4123 4148  
4124 4149                  mutex_enter(&stp->sd_lock);
4125 4150  
4126 4151                  /*
4127 4152                   * As a performance concern we are caching the values of
4128 4153                   * q_minpsz and q_maxpsz of the module below the stream
4129 4154                   * head in the stream head.
4130 4155                   */
4131 4156                  if (!is_insert) {
4132 4157                          mutex_enter(QLOCK(stp->sd_wrq->q_next));
4133 4158                          rmin = stp->sd_wrq->q_next->q_minpsz;
4134 4159                          rmax = stp->sd_wrq->q_next->q_maxpsz;
4135 4160                          mutex_exit(QLOCK(stp->sd_wrq->q_next));
4136 4161  
4137 4162                          /* Do this processing here as a performance concern */
4138 4163                          if (strmsgsz != 0) {
4139 4164                                  if (rmax == INFPSZ) {
4140 4165                                          rmax = strmsgsz;
4141 4166                                  } else  {
4142 4167                                          rmax = MIN(strmsgsz, rmax);
4143 4168                                  }
4144 4169                          }
4145 4170  
4146 4171                          mutex_enter(QLOCK(wrq));
4147 4172                          stp->sd_qn_minpsz = rmin;
4148 4173                          stp->sd_qn_maxpsz = rmax;
4149 4174                          mutex_exit(QLOCK(wrq));
4150 4175                  }
4151 4176  
4152 4177                  /*
4153 4178                   * Need to update the anchor value if this module is
4154 4179                   * inserted below the anchor point.
4155 4180                   */
4156 4181                  if (stp->sd_anchor != 0) {
4157 4182                          pos = STRUCT_FGET(strmodinsert, pos);
4158 4183                          if (pos >= (stp->sd_pushcnt - stp->sd_anchor))
4159 4184                                  stp->sd_anchor++;
4160 4185                  }
4161 4186  
4162 4187                  strendplumb(stp);
4163 4188                  mutex_exit(&stp->sd_lock);
4164 4189                  return (0);
4165 4190          }
4166 4191  
4167 4192          case _I_REMOVE:
4168 4193          {
4169 4194                  /*
4170 4195                   * To remove a module with a given name in a stream.  The
4171 4196                   * caller of this ioctl needs to provide both the name and
4172 4197                   * the position of the module to be removed.  This eliminates
4173 4198                   * the ambiguity of removal if a module is inserted/pushed
4174 4199                   * multiple times in a stream.  In the first release, only
4175 4200                   * allow privileged user to use this ioctl.
4176 4201                   * Furthermore, the remove is only allowed
4177 4202                   * below an anchor if the zoneid is the same as the zoneid
4178 4203                   * which created the anchor.
4179 4204                   *
4180 4205                   * Note that we do not plan to support this ioctl
4181 4206                   * on pipes in the first release.  We want to learn more
4182 4207                   * about the implications of these ioctls before extending
4183 4208                   * their support.  And we do not think these features are
4184 4209                   * valuable for pipes.
4185 4210                   *
4186 4211                   * Also note that _I_REMOVE cannot be used to remove a
4187 4212                   * driver or the stream head.
4188 4213                   */
4189 4214                  STRUCT_DECL(strmodconf, strmodremove);
4190 4215                  queue_t *q;
4191 4216                  int pos;
4192 4217                  char mod_name[FMNAMESZ + 1];
4193 4218                  boolean_t is_remove;
4194 4219  
4195 4220                  STRUCT_INIT(strmodremove, flag);
4196 4221                  if (stp->sd_flag & STRHUP)
4197 4222                          return (ENXIO);
4198 4223                  if (STRMATED(stp))
4199 4224                          return (EINVAL);
4200 4225                  if ((error = secpolicy_net_config(crp, B_FALSE)) != 0)
4201 4226                          return (error);
4202 4227                  if (stp->sd_anchor != 0 &&
4203 4228                      stp->sd_anchorzone != crgetzoneid(crp))
4204 4229                          return (EINVAL);
4205 4230  
4206 4231                  error = strcopyin((void *)arg, STRUCT_BUF(strmodremove),
4207 4232                      STRUCT_SIZE(strmodremove), copyflag);
4208 4233                  if (error)
4209 4234                          return (error);
4210 4235  
4211 4236                  error = (copyflag & U_TO_K ? copyinstr :
4212 4237                      copystr)(STRUCT_FGETP(strmodremove, mod_name),
4213 4238                      mod_name, FMNAMESZ + 1, NULL);
4214 4239                  if (error)
4215 4240                          return ((error == ENAMETOOLONG) ? EINVAL : EFAULT);
4216 4241  
4217 4242                  if ((error = strstartplumb(stp, flag, cmd)) != 0)
4218 4243                          return (error);
4219 4244  
4220 4245                  /*
4221 4246                   * Match the name of given module to the name of module at
4222 4247                   * the given position.
4223 4248                   */
4224 4249                  pos = STRUCT_FGET(strmodremove, pos);
4225 4250  
4226 4251                  is_remove = (pos != 0);
4227 4252                  for (q = stp->sd_wrq->q_next; SAMESTR(q) && pos > 0;
4228 4253                      q = q->q_next, pos--)
4229 4254                          ;
4230 4255                  if (pos > 0 || !SAMESTR(q) ||
4231 4256                      strcmp(Q2NAME(q), mod_name) != 0) {
4232 4257                          mutex_enter(&stp->sd_lock);
4233 4258                          strendplumb(stp);
4234 4259                          mutex_exit(&stp->sd_lock);
4235 4260                          return (EINVAL);
4236 4261                  }
4237 4262  
4238 4263                  /*
4239 4264                   * If the position is at or below an anchor, then the zoneid
4240 4265                   * must match the zoneid that created the anchor.
4241 4266                   */
4242 4267                  if (stp->sd_anchor != 0) {
4243 4268                          pos = STRUCT_FGET(strmodremove, pos);
4244 4269                          if (pos >= (stp->sd_pushcnt - stp->sd_anchor) &&
4245 4270                              stp->sd_anchorzone != crgetzoneid(crp)) {
4246 4271                                  mutex_enter(&stp->sd_lock);
4247 4272                                  strendplumb(stp);
4248 4273                                  mutex_exit(&stp->sd_lock);
4249 4274                                  return (EPERM);
4250 4275                          }
4251 4276                  }
4252 4277  
4253 4278  
4254 4279                  ASSERT(!(q->q_flag & QREADR));
4255 4280                  qdetach(_RD(q), 1, flag, crp, is_remove);
4256 4281  
4257 4282                  mutex_enter(&stp->sd_lock);
4258 4283  
4259 4284                  /*
4260 4285                   * As a performance concern we are caching the values of
4261 4286                   * q_minpsz and q_maxpsz of the module below the stream
4262 4287                   * head in the stream head.
4263 4288                   */
4264 4289                  if (!is_remove) {
4265 4290                          mutex_enter(QLOCK(wrq->q_next));
4266 4291                          rmin = wrq->q_next->q_minpsz;
4267 4292                          rmax = wrq->q_next->q_maxpsz;
4268 4293                          mutex_exit(QLOCK(wrq->q_next));
4269 4294  
4270 4295                          /* Do this processing here as a performance concern */
4271 4296                          if (strmsgsz != 0) {
4272 4297                                  if (rmax == INFPSZ)
4273 4298                                          rmax = strmsgsz;
4274 4299                                  else  {
4275 4300                                          if (vp->v_type == VFIFO)
4276 4301                                                  rmax = MIN(PIPE_BUF, rmax);
4277 4302                                          else    rmax = MIN(strmsgsz, rmax);
4278 4303                                  }
4279 4304                          }
4280 4305  
4281 4306                          mutex_enter(QLOCK(wrq));
4282 4307                          stp->sd_qn_minpsz = rmin;
4283 4308                          stp->sd_qn_maxpsz = rmax;
4284 4309                          mutex_exit(QLOCK(wrq));
4285 4310                  }
4286 4311  
4287 4312                  /*
4288 4313                   * Need to update the anchor value if this module is removed
4289 4314                   * at or below the anchor point.  If the removed module is at
4290 4315                   * the anchor point, remove the anchor for this stream if
4291 4316                   * there is no module above the anchor point.  Otherwise, if
4292 4317                   * the removed module is below the anchor point, decrement the
4293 4318                   * anchor point by 1.
4294 4319                   */
4295 4320                  if (stp->sd_anchor != 0) {
4296 4321                          pos = STRUCT_FGET(strmodremove, pos);
4297 4322                          if (pos == stp->sd_pushcnt - stp->sd_anchor + 1)
4298 4323                                  stp->sd_anchor = 0;
4299 4324                          else if (pos > (stp->sd_pushcnt - stp->sd_anchor + 1))
4300 4325                                  stp->sd_anchor--;
4301 4326                  }
4302 4327  
4303 4328                  strendplumb(stp);
4304 4329                  mutex_exit(&stp->sd_lock);
4305 4330                  return (0);
4306 4331          }
4307 4332  
4308 4333          case I_ANCHOR:
4309 4334                  /*
4310 4335                   * Set the anchor position on the stream to reside at
4311 4336                   * the top module (in other words, the top module
4312 4337                   * cannot be popped).  Anchors with a FIFO make no
4313 4338                   * obvious sense, so they're not allowed.
4314 4339                   */
4315 4340                  mutex_enter(&stp->sd_lock);
4316 4341  
4317 4342                  if (stp->sd_vnode->v_type == VFIFO) {
4318 4343                          mutex_exit(&stp->sd_lock);
4319 4344                          return (EINVAL);
4320 4345                  }
4321 4346                  /* Only allow the same zoneid to update the anchor */
4322 4347                  if (stp->sd_anchor != 0 &&
4323 4348                      stp->sd_anchorzone != crgetzoneid(crp)) {
4324 4349                          mutex_exit(&stp->sd_lock);
4325 4350                          return (EINVAL);
4326 4351                  }
4327 4352                  stp->sd_anchor = stp->sd_pushcnt;
4328 4353                  stp->sd_anchorzone = crgetzoneid(crp);
4329 4354                  mutex_exit(&stp->sd_lock);
4330 4355                  return (0);
4331 4356  
4332 4357          case I_LOOK:
4333 4358                  /*
4334 4359                   * Get name of first module downstream.
4335 4360                   * If no module, return an error.
4336 4361                   */
4337 4362                  claimstr(wrq);
4338 4363                  if (_SAMESTR(wrq) && wrq->q_next->q_next != NULL) {
4339 4364                          char *name = Q2NAME(wrq->q_next);
4340 4365  
4341 4366                          error = strcopyout(name, (void *)arg, strlen(name) + 1,
4342 4367                              copyflag);
4343 4368                          releasestr(wrq);
4344 4369                          return (error);
4345 4370                  }
4346 4371                  releasestr(wrq);
4347 4372                  return (EINVAL);
4348 4373  
4349 4374          case I_LINK:
4350 4375          case I_PLINK:
4351 4376                  /*
4352 4377                   * Link a multiplexor.
4353 4378                   */
4354 4379                  return (mlink(vp, cmd, (int)arg, crp, rvalp, 0));
4355 4380  
4356 4381          case _I_PLINK_LH:
4357 4382                  /*
4358 4383                   * Link a multiplexor: Call must originate from kernel.
4359 4384                   */
4360 4385                  if (kioctl)
4361 4386                          return (ldi_mlink_lh(vp, cmd, arg, crp, rvalp));
4362 4387  
4363 4388                  return (EINVAL);
4364 4389          case I_UNLINK:
4365 4390          case I_PUNLINK:
4366 4391                  /*
4367 4392                   * Unlink a multiplexor.
4368 4393                   * If arg is -1, unlink all links for which this is the
4369 4394                   * controlling stream.  Otherwise, arg is an index number
4370 4395                   * for a link to be removed.
4371 4396                   */
4372 4397          {
4373 4398                  struct linkinfo *linkp;
4374 4399                  int native_arg = (int)arg;
4375 4400                  int type;
4376 4401                  netstack_t *ns;
4377 4402                  str_stack_t *ss;
4378 4403  
4379 4404                  TRACE_1(TR_FAC_STREAMS_FR,
4380 4405                      TR_I_UNLINK, "I_UNLINK/I_PUNLINK:%p", stp);
4381 4406                  if (vp->v_type == VFIFO) {
4382 4407                          return (EINVAL);
4383 4408                  }
4384 4409                  if (cmd == I_UNLINK)
4385 4410                          type = LINKNORMAL;
4386 4411                  else    /* I_PUNLINK */
4387 4412                          type = LINKPERSIST;
4388 4413                  if (native_arg == 0) {
4389 4414                          return (EINVAL);
4390 4415                  }
4391 4416                  ns = netstack_find_by_cred(crp);
4392 4417                  ASSERT(ns != NULL);
4393 4418                  ss = ns->netstack_str;
4394 4419                  ASSERT(ss != NULL);
4395 4420  
4396 4421                  if (native_arg == MUXID_ALL)
4397 4422                          error = munlinkall(stp, type, crp, rvalp, ss);
4398 4423                  else {
4399 4424                          mutex_enter(&muxifier);
4400 4425                          if (!(linkp = findlinks(stp, (int)arg, type, ss))) {
4401 4426                                  /* invalid user supplied index number */
4402 4427                                  mutex_exit(&muxifier);
4403 4428                                  netstack_rele(ss->ss_netstack);
4404 4429                                  return (EINVAL);
4405 4430                          }
4406 4431                          /* munlink drops the muxifier lock */
4407 4432                          error = munlink(stp, linkp, type, crp, rvalp, ss);
4408 4433                  }
4409 4434                  netstack_rele(ss->ss_netstack);
4410 4435                  return (error);
4411 4436          }
4412 4437  
4413 4438          case I_FLUSH:
4414 4439                  /*
4415 4440                   * send a flush message downstream
4416 4441                   * flush message can indicate
4417 4442                   * FLUSHR - flush read queue
4418 4443                   * FLUSHW - flush write queue
4419 4444                   * FLUSHRW - flush read/write queue
4420 4445                   */
4421 4446                  if (stp->sd_flag & STRHUP)
4422 4447                          return (ENXIO);
4423 4448                  if (arg & ~FLUSHRW)
4424 4449                          return (EINVAL);
4425 4450  
4426 4451                  for (;;) {
4427 4452                          if (putnextctl1(stp->sd_wrq, M_FLUSH, (int)arg)) {
4428 4453                                  break;
4429 4454                          }
4430 4455                          if (error = strwaitbuf(1, BPRI_HI)) {
4431 4456                                  return (error);
4432 4457                          }
4433 4458                  }
4434 4459  
4435 4460                  /*
4436 4461                   * Send down an unsupported ioctl and wait for the nack
4437 4462                   * in order to allow the M_FLUSH to propagate back
4438 4463                   * up to the stream head.
4439 4464                   * Replaces if (qready()) runqueues();
4440 4465                   */
4441 4466                  strioc.ic_cmd = -1;     /* The unsupported ioctl */
4442 4467                  strioc.ic_timout = 0;
4443 4468                  strioc.ic_len = 0;
4444 4469                  strioc.ic_dp = NULL;
4445 4470                  (void) strdoioctl(stp, &strioc, flag, K_TO_K, crp, rvalp);
4446 4471                  *rvalp = 0;
4447 4472                  return (0);
4448 4473  
4449 4474          case I_FLUSHBAND:
4450 4475          {
4451 4476                  struct bandinfo binfo;
4452 4477  
4453 4478                  error = strcopyin((void *)arg, &binfo, sizeof (binfo),
4454 4479                      copyflag);
4455 4480                  if (error)
4456 4481                          return (error);
4457 4482                  if (stp->sd_flag & STRHUP)
4458 4483                          return (ENXIO);
4459 4484                  if (binfo.bi_flag & ~FLUSHRW)
4460 4485                          return (EINVAL);
4461 4486                  while (!(mp = allocb(2, BPRI_HI))) {
4462 4487                          if (error = strwaitbuf(2, BPRI_HI))
4463 4488                                  return (error);
4464 4489                  }
4465 4490                  mp->b_datap->db_type = M_FLUSH;
4466 4491                  *mp->b_wptr++ = binfo.bi_flag | FLUSHBAND;
4467 4492                  *mp->b_wptr++ = binfo.bi_pri;
4468 4493                  putnext(stp->sd_wrq, mp);
4469 4494                  /*
4470 4495                   * Send down an unsupported ioctl and wait for the nack
4471 4496                   * in order to allow the M_FLUSH to propagate back
4472 4497                   * up to the stream head.
4473 4498                   * Replaces if (qready()) runqueues();
4474 4499                   */
4475 4500                  strioc.ic_cmd = -1;     /* The unsupported ioctl */
4476 4501                  strioc.ic_timout = 0;
4477 4502                  strioc.ic_len = 0;
4478 4503                  strioc.ic_dp = NULL;
4479 4504                  (void) strdoioctl(stp, &strioc, flag, K_TO_K, crp, rvalp);
4480 4505                  *rvalp = 0;
4481 4506                  return (0);
4482 4507          }
4483 4508  
4484 4509          case I_SRDOPT:
4485 4510                  /*
4486 4511                   * Set read options
4487 4512                   *
4488 4513                   * RNORM - default stream mode
4489 4514                   * RMSGN - message no discard
4490 4515                   * RMSGD - message discard
4491 4516                   * RPROTNORM - fail read with EBADMSG for M_[PC]PROTOs
4492 4517                   * RPROTDAT - convert M_[PC]PROTOs to M_DATAs
4493 4518                   * RPROTDIS - discard M_[PC]PROTOs and retain M_DATAs
4494 4519                   */
4495 4520                  if (arg & ~(RMODEMASK | RPROTMASK))
4496 4521                          return (EINVAL);
4497 4522  
4498 4523                  if ((arg & (RMSGD|RMSGN)) == (RMSGD|RMSGN))
4499 4524                          return (EINVAL);
4500 4525  
4501 4526                  mutex_enter(&stp->sd_lock);
4502 4527                  switch (arg & RMODEMASK) {
4503 4528                  case RNORM:
4504 4529                          stp->sd_read_opt &= ~(RD_MSGDIS | RD_MSGNODIS);
4505 4530                          break;
4506 4531                  case RMSGD:
4507 4532                          stp->sd_read_opt = (stp->sd_read_opt & ~RD_MSGNODIS) |
4508 4533                              RD_MSGDIS;
4509 4534                          break;
4510 4535                  case RMSGN:
4511 4536                          stp->sd_read_opt = (stp->sd_read_opt & ~RD_MSGDIS) |
4512 4537                              RD_MSGNODIS;
4513 4538                          break;
4514 4539                  }
4515 4540  
4516 4541                  switch (arg & RPROTMASK) {
4517 4542                  case RPROTNORM:
4518 4543                          stp->sd_read_opt &= ~(RD_PROTDAT | RD_PROTDIS);
4519 4544                          break;
4520 4545  
4521 4546                  case RPROTDAT:
4522 4547                          stp->sd_read_opt = ((stp->sd_read_opt & ~RD_PROTDIS) |
4523 4548                              RD_PROTDAT);
4524 4549                          break;
4525 4550  
4526 4551                  case RPROTDIS:
4527 4552                          stp->sd_read_opt = ((stp->sd_read_opt & ~RD_PROTDAT) |
4528 4553                              RD_PROTDIS);
4529 4554                          break;
4530 4555                  }
4531 4556                  mutex_exit(&stp->sd_lock);
4532 4557                  return (0);
4533 4558  
4534 4559          case I_GRDOPT:
4535 4560                  /*
4536 4561                   * Get read option and return the value
4537 4562                   * to spot pointed to by arg
4538 4563                   */
4539 4564          {
4540 4565                  int rdopt;
4541 4566  
4542 4567                  rdopt = ((stp->sd_read_opt & RD_MSGDIS) ? RMSGD :
4543 4568                      ((stp->sd_read_opt & RD_MSGNODIS) ? RMSGN : RNORM));
4544 4569                  rdopt |= ((stp->sd_read_opt & RD_PROTDAT) ? RPROTDAT :
4545 4570                      ((stp->sd_read_opt & RD_PROTDIS) ? RPROTDIS : RPROTNORM));
4546 4571  
4547 4572                  return (strcopyout(&rdopt, (void *)arg, sizeof (int),
4548 4573                      copyflag));
4549 4574          }
4550 4575  
4551 4576          case I_SERROPT:
4552 4577                  /*
4553 4578                   * Set error options
4554 4579                   *
4555 4580                   * RERRNORM - persistent read errors
4556 4581                   * RERRNONPERSIST - non-persistent read errors
4557 4582                   * WERRNORM - persistent write errors
4558 4583                   * WERRNONPERSIST - non-persistent write errors
4559 4584                   */
4560 4585                  if (arg & ~(RERRMASK | WERRMASK))
4561 4586                          return (EINVAL);
4562 4587  
4563 4588                  mutex_enter(&stp->sd_lock);
4564 4589                  switch (arg & RERRMASK) {
4565 4590                  case RERRNORM:
4566 4591                          stp->sd_flag &= ~STRDERRNONPERSIST;
4567 4592                          break;
4568 4593                  case RERRNONPERSIST:
4569 4594                          stp->sd_flag |= STRDERRNONPERSIST;
4570 4595                          break;
4571 4596                  }
4572 4597                  switch (arg & WERRMASK) {
4573 4598                  case WERRNORM:
4574 4599                          stp->sd_flag &= ~STWRERRNONPERSIST;
4575 4600                          break;
4576 4601                  case WERRNONPERSIST:
4577 4602                          stp->sd_flag |= STWRERRNONPERSIST;
4578 4603                          break;
4579 4604                  }
4580 4605                  mutex_exit(&stp->sd_lock);
4581 4606                  return (0);
4582 4607  
4583 4608          case I_GERROPT:
4584 4609                  /*
4585 4610                   * Get error option and return the value
4586 4611                   * to spot pointed to by arg
4587 4612                   */
4588 4613          {
4589 4614                  int erropt = 0;
4590 4615  
4591 4616                  erropt |= (stp->sd_flag & STRDERRNONPERSIST) ? RERRNONPERSIST :
4592 4617                      RERRNORM;
4593 4618                  erropt |= (stp->sd_flag & STWRERRNONPERSIST) ? WERRNONPERSIST :
4594 4619                      WERRNORM;
4595 4620                  return (strcopyout(&erropt, (void *)arg, sizeof (int),
4596 4621                      copyflag));
4597 4622          }
4598 4623  
4599 4624          case I_SETSIG:
4600 4625                  /*
4601 4626                   * Register the calling proc to receive the SIGPOLL
4602 4627                   * signal based on the events given in arg.  If
4603 4628                   * arg is zero, remove the proc from register list.
4604 4629                   */
4605 4630          {
4606 4631                  strsig_t *ssp, *pssp;
4607 4632                  struct pid *pidp;
4608 4633  
4609 4634                  pssp = NULL;
4610 4635                  pidp = curproc->p_pidp;
4611 4636                  /*
4612 4637                   * Hold sd_lock to prevent traversal of sd_siglist while
4613 4638                   * it is modified.
4614 4639                   */
4615 4640                  mutex_enter(&stp->sd_lock);
4616 4641                  for (ssp = stp->sd_siglist; ssp && (ssp->ss_pidp != pidp);
4617 4642                      pssp = ssp, ssp = ssp->ss_next)
4618 4643                          ;
4619 4644  
4620 4645                  if (arg) {
4621 4646                          if (arg & ~(S_INPUT|S_HIPRI|S_MSG|S_HANGUP|S_ERROR|
4622 4647                              S_RDNORM|S_WRNORM|S_RDBAND|S_WRBAND|S_BANDURG)) {
4623 4648                                  mutex_exit(&stp->sd_lock);
4624 4649                                  return (EINVAL);
4625 4650                          }
4626 4651                          if ((arg & S_BANDURG) && !(arg & S_RDBAND)) {
4627 4652                                  mutex_exit(&stp->sd_lock);
4628 4653                                  return (EINVAL);
4629 4654                          }
4630 4655  
4631 4656                          /*
4632 4657                           * If proc not already registered, add it
4633 4658                           * to list.
4634 4659                           */
4635 4660                          if (!ssp) {
4636 4661                                  ssp = kmem_alloc(sizeof (strsig_t), KM_SLEEP);
4637 4662                                  ssp->ss_pidp = pidp;
4638 4663                                  ssp->ss_pid = pidp->pid_id;
4639 4664                                  ssp->ss_next = NULL;
4640 4665                                  if (pssp)
4641 4666                                          pssp->ss_next = ssp;
4642 4667                                  else
4643 4668                                          stp->sd_siglist = ssp;
4644 4669                                  mutex_enter(&pidlock);
4645 4670                                  PID_HOLD(pidp);
4646 4671                                  mutex_exit(&pidlock);
4647 4672                          }
4648 4673  
4649 4674                          /*
4650 4675                           * Set events.
4651 4676                           */
4652 4677                          ssp->ss_events = (int)arg;
4653 4678                  } else {
4654 4679                          /*
4655 4680                           * Remove proc from register list.
4656 4681                           */
4657 4682                          if (ssp) {
4658 4683                                  mutex_enter(&pidlock);
4659 4684                                  PID_RELE(pidp);
4660 4685                                  mutex_exit(&pidlock);
4661 4686                                  if (pssp)
4662 4687                                          pssp->ss_next = ssp->ss_next;
4663 4688                                  else
4664 4689                                          stp->sd_siglist = ssp->ss_next;
4665 4690                                  kmem_free(ssp, sizeof (strsig_t));
4666 4691                          } else {
4667 4692                                  mutex_exit(&stp->sd_lock);
4668 4693                                  return (EINVAL);
4669 4694                          }
4670 4695                  }
4671 4696  
4672 4697                  /*
4673 4698                   * Recalculate OR of sig events.
4674 4699                   */
4675 4700                  stp->sd_sigflags = 0;
4676 4701                  for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
4677 4702                          stp->sd_sigflags |= ssp->ss_events;
4678 4703                  mutex_exit(&stp->sd_lock);
4679 4704                  return (0);
4680 4705          }
4681 4706  
4682 4707          case I_GETSIG:
4683 4708                  /*
4684 4709                   * Return (in arg) the current registration of events
4685 4710                   * for which the calling proc is to be signaled.
4686 4711                   */
4687 4712          {
4688 4713                  struct strsig *ssp;
4689 4714                  struct pid  *pidp;
4690 4715  
4691 4716                  pidp = curproc->p_pidp;
4692 4717                  mutex_enter(&stp->sd_lock);
4693 4718                  for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
4694 4719                          if (ssp->ss_pidp == pidp) {
4695 4720                                  error = strcopyout(&ssp->ss_events, (void *)arg,
4696 4721                                      sizeof (int), copyflag);
4697 4722                                  mutex_exit(&stp->sd_lock);
4698 4723                                  return (error);
4699 4724                          }
4700 4725                  mutex_exit(&stp->sd_lock);
4701 4726                  return (EINVAL);
4702 4727          }
4703 4728  
4704 4729          case I_ESETSIG:
4705 4730                  /*
4706 4731                   * Register the ss_pid to receive the SIGPOLL
4707 4732                   * signal based on the events is ss_events arg.  If
4708 4733                   * ss_events is zero, remove the proc from register list.
4709 4734                   */
4710 4735          {
4711 4736                  struct strsig *ssp, *pssp;
4712 4737                  struct proc *proc;
4713 4738                  struct pid  *pidp;
4714 4739                  pid_t pid;
4715 4740                  struct strsigset ss;
4716 4741  
4717 4742                  error = strcopyin((void *)arg, &ss, sizeof (ss), copyflag);
4718 4743                  if (error)
4719 4744                          return (error);
4720 4745  
4721 4746                  pid = ss.ss_pid;
4722 4747  
4723 4748                  if (ss.ss_events != 0) {
4724 4749                          /*
4725 4750                           * Permissions check by sending signal 0.
4726 4751                           * Note that when kill fails it does a set_errno
4727 4752                           * causing the system call to fail.
4728 4753                           */
4729 4754                          error = kill(pid, 0);
4730 4755                          if (error) {
4731 4756                                  return (error);
4732 4757                          }
4733 4758                  }
4734 4759                  mutex_enter(&pidlock);
4735 4760                  if (pid == 0)
4736 4761                          proc = curproc;
4737 4762                  else if (pid < 0)
4738 4763                          proc = pgfind(-pid);
4739 4764                  else
4740 4765                          proc = prfind(pid);
4741 4766                  if (proc == NULL) {
4742 4767                          mutex_exit(&pidlock);
4743 4768                          return (ESRCH);
4744 4769                  }
4745 4770                  if (pid < 0)
4746 4771                          pidp = proc->p_pgidp;
4747 4772                  else
4748 4773                          pidp = proc->p_pidp;
4749 4774                  ASSERT(pidp);
4750 4775                  /*
4751 4776                   * Get a hold on the pid structure while referencing it.
4752 4777                   * There is a separate PID_HOLD should it be inserted
4753 4778                   * in the list below.
4754 4779                   */
4755 4780                  PID_HOLD(pidp);
4756 4781                  mutex_exit(&pidlock);
4757 4782  
4758 4783                  pssp = NULL;
4759 4784                  /*
4760 4785                   * Hold sd_lock to prevent traversal of sd_siglist while
4761 4786                   * it is modified.
4762 4787                   */
4763 4788                  mutex_enter(&stp->sd_lock);
4764 4789                  for (ssp = stp->sd_siglist; ssp && (ssp->ss_pid != pid);
4765 4790                      pssp = ssp, ssp = ssp->ss_next)
4766 4791                          ;
4767 4792  
4768 4793                  if (ss.ss_events) {
4769 4794                          if (ss.ss_events &
4770 4795                              ~(S_INPUT|S_HIPRI|S_MSG|S_HANGUP|S_ERROR|
4771 4796                              S_RDNORM|S_WRNORM|S_RDBAND|S_WRBAND|S_BANDURG)) {
4772 4797                                  mutex_exit(&stp->sd_lock);
4773 4798                                  mutex_enter(&pidlock);
4774 4799                                  PID_RELE(pidp);
4775 4800                                  mutex_exit(&pidlock);
4776 4801                                  return (EINVAL);
4777 4802                          }
4778 4803                          if ((ss.ss_events & S_BANDURG) &&
4779 4804                              !(ss.ss_events & S_RDBAND)) {
4780 4805                                  mutex_exit(&stp->sd_lock);
4781 4806                                  mutex_enter(&pidlock);
4782 4807                                  PID_RELE(pidp);
4783 4808                                  mutex_exit(&pidlock);
4784 4809                                  return (EINVAL);
4785 4810                          }
4786 4811  
4787 4812                          /*
4788 4813                           * If proc not already registered, add it
4789 4814                           * to list.
4790 4815                           */
4791 4816                          if (!ssp) {
4792 4817                                  ssp = kmem_alloc(sizeof (strsig_t), KM_SLEEP);
4793 4818                                  ssp->ss_pidp = pidp;
4794 4819                                  ssp->ss_pid = pid;
4795 4820                                  ssp->ss_next = NULL;
4796 4821                                  if (pssp)
4797 4822                                          pssp->ss_next = ssp;
4798 4823                                  else
4799 4824                                          stp->sd_siglist = ssp;
4800 4825                                  mutex_enter(&pidlock);
4801 4826                                  PID_HOLD(pidp);
4802 4827                                  mutex_exit(&pidlock);
4803 4828                          }
4804 4829  
4805 4830                          /*
4806 4831                           * Set events.
4807 4832                           */
4808 4833                          ssp->ss_events = ss.ss_events;
4809 4834                  } else {
4810 4835                          /*
4811 4836                           * Remove proc from register list.
4812 4837                           */
4813 4838                          if (ssp) {
4814 4839                                  mutex_enter(&pidlock);
4815 4840                                  PID_RELE(pidp);
4816 4841                                  mutex_exit(&pidlock);
4817 4842                                  if (pssp)
4818 4843                                          pssp->ss_next = ssp->ss_next;
4819 4844                                  else
4820 4845                                          stp->sd_siglist = ssp->ss_next;
4821 4846                                  kmem_free(ssp, sizeof (strsig_t));
4822 4847                          } else {
4823 4848                                  mutex_exit(&stp->sd_lock);
4824 4849                                  mutex_enter(&pidlock);
4825 4850                                  PID_RELE(pidp);
4826 4851                                  mutex_exit(&pidlock);
4827 4852                                  return (EINVAL);
4828 4853                          }
4829 4854                  }
4830 4855  
4831 4856                  /*
4832 4857                   * Recalculate OR of sig events.
4833 4858                   */
4834 4859                  stp->sd_sigflags = 0;
4835 4860                  for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
4836 4861                          stp->sd_sigflags |= ssp->ss_events;
4837 4862                  mutex_exit(&stp->sd_lock);
4838 4863                  mutex_enter(&pidlock);
4839 4864                  PID_RELE(pidp);
4840 4865                  mutex_exit(&pidlock);
4841 4866                  return (0);
4842 4867          }
4843 4868  
4844 4869          case I_EGETSIG:
4845 4870                  /*
4846 4871                   * Return (in arg) the current registration of events
4847 4872                   * for which the calling proc is to be signaled.
4848 4873                   */
4849 4874          {
4850 4875                  struct strsig *ssp;
4851 4876                  struct proc *proc;
4852 4877                  pid_t pid;
4853 4878                  struct pid  *pidp;
4854 4879                  struct strsigset ss;
4855 4880  
4856 4881                  error = strcopyin((void *)arg, &ss, sizeof (ss), copyflag);
4857 4882                  if (error)
4858 4883                          return (error);
4859 4884  
4860 4885                  pid = ss.ss_pid;
4861 4886                  mutex_enter(&pidlock);
4862 4887                  if (pid == 0)
4863 4888                          proc = curproc;
4864 4889                  else if (pid < 0)
4865 4890                          proc = pgfind(-pid);
4866 4891                  else
4867 4892                          proc = prfind(pid);
4868 4893                  if (proc == NULL) {
4869 4894                          mutex_exit(&pidlock);
4870 4895                          return (ESRCH);
4871 4896                  }
4872 4897                  if (pid < 0)
4873 4898                          pidp = proc->p_pgidp;
4874 4899                  else
4875 4900                          pidp = proc->p_pidp;
4876 4901  
4877 4902                  /* Prevent the pidp from being reassigned */
4878 4903                  PID_HOLD(pidp);
4879 4904                  mutex_exit(&pidlock);
4880 4905  
4881 4906                  mutex_enter(&stp->sd_lock);
4882 4907                  for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
4883 4908                          if (ssp->ss_pid == pid) {
4884 4909                                  ss.ss_pid = ssp->ss_pid;
4885 4910                                  ss.ss_events = ssp->ss_events;
4886 4911                                  error = strcopyout(&ss, (void *)arg,
4887 4912                                      sizeof (struct strsigset), copyflag);
4888 4913                                  mutex_exit(&stp->sd_lock);
4889 4914                                  mutex_enter(&pidlock);
4890 4915                                  PID_RELE(pidp);
4891 4916                                  mutex_exit(&pidlock);
4892 4917                                  return (error);
4893 4918                          }
4894 4919                  mutex_exit(&stp->sd_lock);
4895 4920                  mutex_enter(&pidlock);
4896 4921                  PID_RELE(pidp);
4897 4922                  mutex_exit(&pidlock);
4898 4923                  return (EINVAL);
4899 4924          }
4900 4925  
4901 4926          case I_PEEK:
4902 4927          {
4903 4928                  STRUCT_DECL(strpeek, strpeek);
4904 4929                  size_t n;
4905 4930                  mblk_t *fmp, *tmp_mp = NULL;
4906 4931  
4907 4932                  STRUCT_INIT(strpeek, flag);
4908 4933  
4909 4934                  error = strcopyin((void *)arg, STRUCT_BUF(strpeek),
4910 4935                      STRUCT_SIZE(strpeek), copyflag);
4911 4936                  if (error)
4912 4937                          return (error);
4913 4938  
4914 4939                  mutex_enter(QLOCK(rdq));
4915 4940                  /*
4916 4941                   * Skip the invalid messages
4917 4942                   */
4918 4943                  for (mp = rdq->q_first; mp != NULL; mp = mp->b_next)
4919 4944                          if (mp->b_datap->db_type != M_SIG)
4920 4945                                  break;
4921 4946  
4922 4947                  /*
4923 4948                   * If user has requested to peek at a high priority message
4924 4949                   * and first message is not, return 0
4925 4950                   */
4926 4951                  if (mp != NULL) {
4927 4952                          if ((STRUCT_FGET(strpeek, flags) & RS_HIPRI) &&
4928 4953                              queclass(mp) == QNORM) {
4929 4954                                  *rvalp = 0;
4930 4955                                  mutex_exit(QLOCK(rdq));
4931 4956                                  return (0);
4932 4957                          }
4933 4958                  } else if (stp->sd_struiordq == NULL ||
4934 4959                      (STRUCT_FGET(strpeek, flags) & RS_HIPRI)) {
4935 4960                          /*
4936 4961                           * No mblks to look at at the streamhead and
4937 4962                           * 1). This isn't a synch stream or
4938 4963                           * 2). This is a synch stream but caller wants high
4939 4964                           *      priority messages which is not supported by
4940 4965                           *      the synch stream. (it only supports QNORM)
4941 4966                           */
4942 4967                          *rvalp = 0;
4943 4968                          mutex_exit(QLOCK(rdq));
4944 4969                          return (0);
4945 4970                  }
4946 4971  
4947 4972                  fmp = mp;
4948 4973  
4949 4974                  if (mp && mp->b_datap->db_type == M_PASSFP) {
4950 4975                          mutex_exit(QLOCK(rdq));
4951 4976                          return (EBADMSG);
4952 4977                  }
4953 4978  
4954 4979                  ASSERT(mp == NULL || mp->b_datap->db_type == M_PCPROTO ||
4955 4980                      mp->b_datap->db_type == M_PROTO ||
4956 4981                      mp->b_datap->db_type == M_DATA);
4957 4982  
4958 4983                  if (mp && mp->b_datap->db_type == M_PCPROTO) {
4959 4984                          STRUCT_FSET(strpeek, flags, RS_HIPRI);
4960 4985                  } else {
4961 4986                          STRUCT_FSET(strpeek, flags, 0);
4962 4987                  }
4963 4988  
4964 4989  
4965 4990                  if (mp && ((tmp_mp = dupmsg(mp)) == NULL)) {
4966 4991                          mutex_exit(QLOCK(rdq));
4967 4992                          return (ENOSR);
4968 4993                  }
4969 4994                  mutex_exit(QLOCK(rdq));
4970 4995  
4971 4996                  /*
4972 4997                   * set mp = tmp_mp, so that I_PEEK processing can continue.
4973 4998                   * tmp_mp is used to free the dup'd message.
4974 4999                   */
4975 5000                  mp = tmp_mp;
4976 5001  
4977 5002                  uio.uio_fmode = 0;
4978 5003                  uio.uio_extflg = UIO_COPY_CACHED;
4979 5004                  uio.uio_segflg = (copyflag == U_TO_K) ? UIO_USERSPACE :
4980 5005                      UIO_SYSSPACE;
4981 5006                  uio.uio_limit = 0;
4982 5007                  /*
4983 5008                   * First process PROTO blocks, if any.
4984 5009                   * If user doesn't want to get ctl info by setting maxlen <= 0,
4985 5010                   * then set len to -1/0 and skip control blocks part.
4986 5011                   */
4987 5012                  if (STRUCT_FGET(strpeek, ctlbuf.maxlen) < 0)
4988 5013                          STRUCT_FSET(strpeek, ctlbuf.len, -1);
4989 5014                  else if (STRUCT_FGET(strpeek, ctlbuf.maxlen) == 0)
4990 5015                          STRUCT_FSET(strpeek, ctlbuf.len, 0);
4991 5016                  else {
4992 5017                          int     ctl_part = 0;
4993 5018  
4994 5019                          iov.iov_base = STRUCT_FGETP(strpeek, ctlbuf.buf);
4995 5020                          iov.iov_len = STRUCT_FGET(strpeek, ctlbuf.maxlen);
4996 5021                          uio.uio_iov = &iov;
4997 5022                          uio.uio_resid = iov.iov_len;
4998 5023                          uio.uio_loffset = 0;
4999 5024                          uio.uio_iovcnt = 1;
5000 5025                          while (mp && mp->b_datap->db_type != M_DATA &&
5001 5026                              uio.uio_resid >= 0) {
5002 5027                                  ASSERT(STRUCT_FGET(strpeek, flags) == 0 ?
5003 5028                                      mp->b_datap->db_type == M_PROTO :
5004 5029                                      mp->b_datap->db_type == M_PCPROTO);
5005 5030  
5006 5031                                  if ((n = MIN(uio.uio_resid,
5007 5032                                      mp->b_wptr - mp->b_rptr)) != 0 &&
5008 5033                                      (error = uiomove((char *)mp->b_rptr, n,
5009 5034                                      UIO_READ, &uio)) != 0) {
5010 5035                                          freemsg(tmp_mp);
5011 5036                                          return (error);
5012 5037                                  }
5013 5038                                  ctl_part = 1;
5014 5039                                  mp = mp->b_cont;
5015 5040                          }
5016 5041                          /* No ctl message */
5017 5042                          if (ctl_part == 0)
5018 5043                                  STRUCT_FSET(strpeek, ctlbuf.len, -1);
5019 5044                          else
5020 5045                                  STRUCT_FSET(strpeek, ctlbuf.len,
5021 5046                                      STRUCT_FGET(strpeek, ctlbuf.maxlen) -
5022 5047                                      uio.uio_resid);
5023 5048                  }
5024 5049  
5025 5050                  /*
5026 5051                   * Now process DATA blocks, if any.
5027 5052                   * If user doesn't want to get data info by setting maxlen <= 0,
5028 5053                   * then set len to -1/0 and skip data blocks part.
5029 5054                   */
5030 5055                  if (STRUCT_FGET(strpeek, databuf.maxlen) < 0)
5031 5056                          STRUCT_FSET(strpeek, databuf.len, -1);
5032 5057                  else if (STRUCT_FGET(strpeek, databuf.maxlen) == 0)
5033 5058                          STRUCT_FSET(strpeek, databuf.len, 0);
5034 5059                  else {
5035 5060                          int     data_part = 0;
5036 5061  
5037 5062                          iov.iov_base = STRUCT_FGETP(strpeek, databuf.buf);
5038 5063                          iov.iov_len = STRUCT_FGET(strpeek, databuf.maxlen);
5039 5064                          uio.uio_iov = &iov;
5040 5065                          uio.uio_resid = iov.iov_len;
5041 5066                          uio.uio_loffset = 0;
5042 5067                          uio.uio_iovcnt = 1;
5043 5068                          while (mp && uio.uio_resid) {
5044 5069                                  if (mp->b_datap->db_type == M_DATA) {
5045 5070                                          if ((n = MIN(uio.uio_resid,
5046 5071                                              mp->b_wptr - mp->b_rptr)) != 0 &&
5047 5072                                              (error = uiomove((char *)mp->b_rptr,
5048 5073                                              n, UIO_READ, &uio)) != 0) {
5049 5074                                                  freemsg(tmp_mp);
5050 5075                                                  return (error);
5051 5076                                          }
5052 5077                                          data_part = 1;
5053 5078                                  }
5054 5079                                  ASSERT(data_part == 0 ||
5055 5080                                      mp->b_datap->db_type == M_DATA);
5056 5081                                  mp = mp->b_cont;
5057 5082                          }
5058 5083                          /* No data message */
5059 5084                          if (data_part == 0)
5060 5085                                  STRUCT_FSET(strpeek, databuf.len, -1);
5061 5086                          else
5062 5087                                  STRUCT_FSET(strpeek, databuf.len,
5063 5088                                      STRUCT_FGET(strpeek, databuf.maxlen) -
5064 5089                                      uio.uio_resid);
5065 5090                  }
5066 5091                  freemsg(tmp_mp);
5067 5092  
5068 5093                  /*
5069 5094                   * It is a synch stream and user wants to get
5070 5095                   * data (maxlen > 0).
5071 5096                   * uio setup is done by the codes that process DATA
5072 5097                   * blocks above.
5073 5098                   */
5074 5099                  if ((fmp == NULL) && STRUCT_FGET(strpeek, databuf.maxlen) > 0) {
5075 5100                          infod_t infod;
5076 5101  
5077 5102                          infod.d_cmd = INFOD_COPYOUT;
5078 5103                          infod.d_res = 0;
5079 5104                          infod.d_uiop = &uio;
5080 5105                          error = infonext(rdq, &infod);
5081 5106                          if (error == EINVAL || error == EBUSY)
5082 5107                                  error = 0;
5083 5108                          if (error)
5084 5109                                  return (error);
5085 5110                          STRUCT_FSET(strpeek, databuf.len, STRUCT_FGET(strpeek,
5086 5111                              databuf.maxlen) - uio.uio_resid);
5087 5112                          if (STRUCT_FGET(strpeek, databuf.len) == 0) {
5088 5113                                  /*
5089 5114                                   * No data found by the infonext().
5090 5115                                   */
5091 5116                                  STRUCT_FSET(strpeek, databuf.len, -1);
5092 5117                          }
5093 5118                  }
5094 5119                  error = strcopyout(STRUCT_BUF(strpeek), (void *)arg,
5095 5120                      STRUCT_SIZE(strpeek), copyflag);
5096 5121                  if (error) {
5097 5122                          return (error);
5098 5123                  }
5099 5124                  /*
5100 5125                   * If there is no message retrieved, set return code to 0
5101 5126                   * otherwise, set it to 1.
5102 5127                   */
5103 5128                  if (STRUCT_FGET(strpeek, ctlbuf.len) == -1 &&
5104 5129                      STRUCT_FGET(strpeek, databuf.len) == -1)
5105 5130                          *rvalp = 0;
5106 5131                  else
5107 5132                          *rvalp = 1;
5108 5133                  return (0);
5109 5134          }
5110 5135  
5111 5136          case I_FDINSERT:
5112 5137          {
5113 5138                  STRUCT_DECL(strfdinsert, strfdinsert);
5114 5139                  struct file *resftp;
5115 5140                  struct stdata *resstp;
5116 5141                  t_uscalar_t     ival;
5117 5142                  ssize_t msgsize;
5118 5143                  struct strbuf mctl;
5119 5144  
5120 5145                  STRUCT_INIT(strfdinsert, flag);
5121 5146                  if (stp->sd_flag & STRHUP)
5122 5147                          return (ENXIO);
5123 5148                  /*
5124 5149                   * STRDERR, STWRERR and STPLEX tested above.
5125 5150                   */
5126 5151                  error = strcopyin((void *)arg, STRUCT_BUF(strfdinsert),
5127 5152                      STRUCT_SIZE(strfdinsert), copyflag);
5128 5153                  if (error)
5129 5154                          return (error);
5130 5155  
5131 5156                  if (STRUCT_FGET(strfdinsert, offset) < 0 ||
5132 5157                      (STRUCT_FGET(strfdinsert, offset) %
5133 5158                      sizeof (t_uscalar_t)) != 0)
5134 5159                          return (EINVAL);
5135 5160                  if ((resftp = getf(STRUCT_FGET(strfdinsert, fildes))) != NULL) {
5136 5161                          if ((resstp = resftp->f_vnode->v_stream) == NULL) {
5137 5162                                  releasef(STRUCT_FGET(strfdinsert, fildes));
5138 5163                                  return (EINVAL);
5139 5164                          }
5140 5165                  } else
5141 5166                          return (EINVAL);
5142 5167  
5143 5168                  mutex_enter(&resstp->sd_lock);
5144 5169                  if (resstp->sd_flag & (STRDERR|STWRERR|STRHUP|STPLEX)) {
5145 5170                          error = strgeterr(resstp,
5146 5171                              STRDERR|STWRERR|STRHUP|STPLEX, 0);
5147 5172                          if (error != 0) {
5148 5173                                  mutex_exit(&resstp->sd_lock);
5149 5174                                  releasef(STRUCT_FGET(strfdinsert, fildes));
5150 5175                                  return (error);
5151 5176                          }
5152 5177                  }
5153 5178                  mutex_exit(&resstp->sd_lock);
5154 5179  
5155 5180  #ifdef  _ILP32
5156 5181                  {
5157 5182                          queue_t *q;
5158 5183                          queue_t *mate = NULL;
5159 5184  
5160 5185                          /* get read queue of stream terminus */
5161 5186                          claimstr(resstp->sd_wrq);
5162 5187                          for (q = resstp->sd_wrq->q_next; q->q_next != NULL;
5163 5188                              q = q->q_next)
5164 5189                                  if (!STRMATED(resstp) && STREAM(q) != resstp &&
5165 5190                                      mate == NULL) {
5166 5191                                          ASSERT(q->q_qinfo->qi_srvp);
5167 5192                                          ASSERT(_OTHERQ(q)->q_qinfo->qi_srvp);
5168 5193                                          claimstr(q);
5169 5194                                          mate = q;
5170 5195                                  }
5171 5196                          q = _RD(q);
5172 5197                          if (mate)
5173 5198                                  releasestr(mate);
5174 5199                          releasestr(resstp->sd_wrq);
5175 5200                          ival = (t_uscalar_t)q;
5176 5201                  }
5177 5202  #else
5178 5203                  ival = (t_uscalar_t)getminor(resftp->f_vnode->v_rdev);
5179 5204  #endif  /* _ILP32 */
5180 5205  
5181 5206                  if (STRUCT_FGET(strfdinsert, ctlbuf.len) <
5182 5207                      STRUCT_FGET(strfdinsert, offset) + sizeof (t_uscalar_t)) {
5183 5208                          releasef(STRUCT_FGET(strfdinsert, fildes));
5184 5209                          return (EINVAL);
5185 5210                  }
5186 5211  
5187 5212                  /*
5188 5213                   * Check for legal flag value.
5189 5214                   */
5190 5215                  if (STRUCT_FGET(strfdinsert, flags) & ~RS_HIPRI) {
5191 5216                          releasef(STRUCT_FGET(strfdinsert, fildes));
5192 5217                          return (EINVAL);
5193 5218                  }
5194 5219  
5195 5220                  /* get these values from those cached in the stream head */
5196 5221                  mutex_enter(QLOCK(stp->sd_wrq));
5197 5222                  rmin = stp->sd_qn_minpsz;
5198 5223                  rmax = stp->sd_qn_maxpsz;
5199 5224                  mutex_exit(QLOCK(stp->sd_wrq));
5200 5225  
5201 5226                  /*
5202 5227                   * Make sure ctl and data sizes together fall within
5203 5228                   * the limits of the max and min receive packet sizes
5204 5229                   * and do not exceed system limit.  A negative data
5205 5230                   * length means that no data part is to be sent.
5206 5231                   */
5207 5232                  ASSERT((rmax >= 0) || (rmax == INFPSZ));
5208 5233                  if (rmax == 0) {
5209 5234                          releasef(STRUCT_FGET(strfdinsert, fildes));
5210 5235                          return (ERANGE);
5211 5236                  }
5212 5237                  if ((msgsize = STRUCT_FGET(strfdinsert, databuf.len)) < 0)
5213 5238                          msgsize = 0;
5214 5239                  if ((msgsize < rmin) ||
5215 5240                      ((msgsize > rmax) && (rmax != INFPSZ)) ||
5216 5241                      (STRUCT_FGET(strfdinsert, ctlbuf.len) > strctlsz)) {
5217 5242                          releasef(STRUCT_FGET(strfdinsert, fildes));
5218 5243                          return (ERANGE);
5219 5244                  }
5220 5245  
5221 5246                  mutex_enter(&stp->sd_lock);
5222 5247                  while (!(STRUCT_FGET(strfdinsert, flags) & RS_HIPRI) &&
5223 5248                      !canputnext(stp->sd_wrq)) {
5224 5249                          if ((error = strwaitq(stp, WRITEWAIT, (ssize_t)0,
5225 5250                              flag, -1, &done)) != 0 || done) {
5226 5251                                  mutex_exit(&stp->sd_lock);
5227 5252                                  releasef(STRUCT_FGET(strfdinsert, fildes));
5228 5253                                  return (error);
5229 5254                          }
5230 5255                          if ((error = i_straccess(stp, access)) != 0) {
5231 5256                                  mutex_exit(&stp->sd_lock);
5232 5257                                  releasef(
5233 5258                                      STRUCT_FGET(strfdinsert, fildes));
5234 5259                                  return (error);
5235 5260                          }
5236 5261                  }
5237 5262                  mutex_exit(&stp->sd_lock);
5238 5263  
5239 5264                  /*
5240 5265                   * Copy strfdinsert.ctlbuf into native form of
5241 5266                   * ctlbuf to pass down into strmakemsg().
5242 5267                   */
5243 5268                  mctl.maxlen = STRUCT_FGET(strfdinsert, ctlbuf.maxlen);
5244 5269                  mctl.len = STRUCT_FGET(strfdinsert, ctlbuf.len);
5245 5270                  mctl.buf = STRUCT_FGETP(strfdinsert, ctlbuf.buf);
5246 5271  
5247 5272                  iov.iov_base = STRUCT_FGETP(strfdinsert, databuf.buf);
5248 5273                  iov.iov_len = STRUCT_FGET(strfdinsert, databuf.len);
5249 5274                  uio.uio_iov = &iov;
5250 5275                  uio.uio_iovcnt = 1;
5251 5276                  uio.uio_loffset = 0;
5252 5277                  uio.uio_segflg = (copyflag == U_TO_K) ? UIO_USERSPACE :
5253 5278                      UIO_SYSSPACE;
5254 5279                  uio.uio_fmode = 0;
5255 5280                  uio.uio_extflg = UIO_COPY_CACHED;
5256 5281                  uio.uio_resid = iov.iov_len;
5257 5282                  if ((error = strmakemsg(&mctl,
5258 5283                      &msgsize, &uio, stp,
5259 5284                      STRUCT_FGET(strfdinsert, flags), &mp)) != 0 || !mp) {
5260 5285                          STRUCT_FSET(strfdinsert, databuf.len, msgsize);
5261 5286                          releasef(STRUCT_FGET(strfdinsert, fildes));
5262 5287                          return (error);
5263 5288                  }
5264 5289  
5265 5290                  STRUCT_FSET(strfdinsert, databuf.len, msgsize);
5266 5291  
5267 5292                  /*
5268 5293                   * Place the possibly reencoded queue pointer 'offset' bytes
5269 5294                   * from the start of the control portion of the message.
5270 5295                   */
5271 5296                  *((t_uscalar_t *)(mp->b_rptr +
5272 5297                      STRUCT_FGET(strfdinsert, offset))) = ival;
5273 5298  
5274 5299                  /*
5275 5300                   * Put message downstream.
5276 5301                   */
5277 5302                  stream_willservice(stp);
5278 5303                  putnext(stp->sd_wrq, mp);
5279 5304                  stream_runservice(stp);
5280 5305                  releasef(STRUCT_FGET(strfdinsert, fildes));
5281 5306                  return (error);
5282 5307          }
5283 5308  
5284 5309          case I_SENDFD:
5285 5310          {
5286 5311                  struct file *fp;
5287 5312  
5288 5313                  if ((fp = getf((int)arg)) == NULL)
5289 5314                          return (EBADF);
5290 5315                  error = do_sendfp(stp, fp, crp);
5291 5316                  if (auditing) {
5292 5317                          audit_fdsend((int)arg, fp, error);
5293 5318                  }
5294 5319                  releasef((int)arg);
5295 5320                  return (error);
5296 5321          }
5297 5322  
5298 5323          case I_RECVFD:
5299 5324          case I_E_RECVFD:
5300 5325          {
5301 5326                  struct k_strrecvfd *srf;
5302 5327                  int i, fd;
5303 5328  
5304 5329                  mutex_enter(&stp->sd_lock);
5305 5330                  while (!(mp = getq(rdq))) {
5306 5331                          if (stp->sd_flag & (STRHUP|STREOF)) {
5307 5332                                  mutex_exit(&stp->sd_lock);
5308 5333                                  return (ENXIO);
5309 5334                          }
5310 5335                          if ((error = strwaitq(stp, GETWAIT, (ssize_t)0,
5311 5336                              flag, -1, &done)) != 0 || done) {
5312 5337                                  mutex_exit(&stp->sd_lock);
5313 5338                                  return (error);
5314 5339                          }
5315 5340                          if ((error = i_straccess(stp, access)) != 0) {
5316 5341                                  mutex_exit(&stp->sd_lock);
5317 5342                                  return (error);
5318 5343                          }
5319 5344                  }
5320 5345                  if (mp->b_datap->db_type != M_PASSFP) {
5321 5346                          putback(stp, rdq, mp, mp->b_band);
5322 5347                          mutex_exit(&stp->sd_lock);
5323 5348                          return (EBADMSG);
5324 5349                  }
5325 5350                  mutex_exit(&stp->sd_lock);
5326 5351  
5327 5352                  srf = (struct k_strrecvfd *)mp->b_rptr;
5328 5353                  if ((fd = ufalloc(0)) == -1) {
5329 5354                          mutex_enter(&stp->sd_lock);
5330 5355                          putback(stp, rdq, mp, mp->b_band);
5331 5356                          mutex_exit(&stp->sd_lock);
5332 5357                          return (EMFILE);
5333 5358                  }
5334 5359                  if (cmd == I_RECVFD) {
5335 5360                          struct o_strrecvfd      ostrfd;
5336 5361  
5337 5362                          /* check to see if uid/gid values are too large. */
5338 5363  
5339 5364                          if (srf->uid > (o_uid_t)USHRT_MAX ||
5340 5365                              srf->gid > (o_gid_t)USHRT_MAX) {
5341 5366                                  mutex_enter(&stp->sd_lock);
5342 5367                                  putback(stp, rdq, mp, mp->b_band);
5343 5368                                  mutex_exit(&stp->sd_lock);
5344 5369                                  setf(fd, NULL); /* release fd entry */
5345 5370                                  return (EOVERFLOW);
5346 5371                          }
5347 5372  
5348 5373                          ostrfd.fd = fd;
5349 5374                          ostrfd.uid = (o_uid_t)srf->uid;
5350 5375                          ostrfd.gid = (o_gid_t)srf->gid;
5351 5376  
5352 5377                          /* Null the filler bits */
5353 5378                          for (i = 0; i < 8; i++)
5354 5379                                  ostrfd.fill[i] = 0;
5355 5380  
5356 5381                          error = strcopyout(&ostrfd, (void *)arg,
5357 5382                              sizeof (struct o_strrecvfd), copyflag);
5358 5383                  } else {                /* I_E_RECVFD */
5359 5384                          struct strrecvfd        strfd;
5360 5385  
5361 5386                          strfd.fd = fd;
5362 5387                          strfd.uid = srf->uid;
5363 5388                          strfd.gid = srf->gid;
5364 5389  
5365 5390                          /* null the filler bits */
5366 5391                          for (i = 0; i < 8; i++)
5367 5392                                  strfd.fill[i] = 0;
5368 5393  
5369 5394                          error = strcopyout(&strfd, (void *)arg,
5370 5395                              sizeof (struct strrecvfd), copyflag);
5371 5396                  }
5372 5397  
5373 5398                  if (error) {
5374 5399                          setf(fd, NULL); /* release fd entry */
5375 5400                          mutex_enter(&stp->sd_lock);
5376 5401                          putback(stp, rdq, mp, mp->b_band);
5377 5402                          mutex_exit(&stp->sd_lock);
5378 5403                          return (error);
5379 5404                  }
5380 5405                  if (auditing) {
5381 5406                          audit_fdrecv(fd, srf->fp);
5382 5407                  }
5383 5408  
5384 5409                  /*
5385 5410                   * Always increment f_count since the freemsg() below will
5386 5411                   * always call free_passfp() which performs a closef().
5387 5412                   */
5388 5413                  mutex_enter(&srf->fp->f_tlock);
5389 5414                  srf->fp->f_count++;
5390 5415                  mutex_exit(&srf->fp->f_tlock);
5391 5416                  setf(fd, srf->fp);
5392 5417                  freemsg(mp);
5393 5418                  return (0);
5394 5419          }
5395 5420  
5396 5421          case I_SWROPT:
5397 5422                  /*
5398 5423                   * Set/clear the write options. arg is a bit
5399 5424                   * mask with any of the following bits set...
5400 5425                   *      SNDZERO - send zero length message
5401 5426                   *      SNDPIPE - send sigpipe to process if
5402 5427                   *              sd_werror is set and process is
5403 5428                   *              doing a write or putmsg.
5404 5429                   * The new stream head write options should reflect
5405 5430                   * what is in arg.
5406 5431                   */
5407 5432                  if (arg & ~(SNDZERO|SNDPIPE))
5408 5433                          return (EINVAL);
5409 5434  
5410 5435                  mutex_enter(&stp->sd_lock);
5411 5436                  stp->sd_wput_opt &= ~(SW_SIGPIPE|SW_SNDZERO);
5412 5437                  if (arg & SNDZERO)
5413 5438                          stp->sd_wput_opt |= SW_SNDZERO;
5414 5439                  if (arg & SNDPIPE)
5415 5440                          stp->sd_wput_opt |= SW_SIGPIPE;
5416 5441                  mutex_exit(&stp->sd_lock);
5417 5442                  return (0);
5418 5443  
5419 5444          case I_GWROPT:
5420 5445          {
5421 5446                  int wropt = 0;
5422 5447  
5423 5448                  if (stp->sd_wput_opt & SW_SNDZERO)
5424 5449                          wropt |= SNDZERO;
5425 5450                  if (stp->sd_wput_opt & SW_SIGPIPE)
5426 5451                          wropt |= SNDPIPE;
5427 5452                  return (strcopyout(&wropt, (void *)arg, sizeof (wropt),
5428 5453                      copyflag));
5429 5454          }
5430 5455  
5431 5456          case I_LIST:
5432 5457                  /*
5433 5458                   * Returns all the modules found on this stream,
5434 5459                   * upto the driver. If argument is NULL, return the
5435 5460                   * number of modules (including driver). If argument
5436 5461                   * is not NULL, copy the names into the structure
5437 5462                   * provided.
5438 5463                   */
5439 5464  
5440 5465          {
5441 5466                  queue_t *q;
5442 5467                  char *qname;
5443 5468                  int i, nmods;
5444 5469                  struct str_mlist *mlist;
5445 5470                  STRUCT_DECL(str_list, strlist);
5446 5471  
5447 5472                  if (arg == NULL) { /* Return number of modules plus driver */
5448 5473                          if (stp->sd_vnode->v_type == VFIFO)
5449 5474                                  *rvalp = stp->sd_pushcnt;
5450 5475                          else
5451 5476                                  *rvalp = stp->sd_pushcnt + 1;
5452 5477                          return (0);
5453 5478                  }
5454 5479  
5455 5480                  STRUCT_INIT(strlist, flag);
5456 5481  
5457 5482                  error = strcopyin((void *)arg, STRUCT_BUF(strlist),
5458 5483                      STRUCT_SIZE(strlist), copyflag);
5459 5484                  if (error != 0)
5460 5485                          return (error);
5461 5486  
5462 5487                  mlist = STRUCT_FGETP(strlist, sl_modlist);
5463 5488                  nmods = STRUCT_FGET(strlist, sl_nmods);
5464 5489                  if (nmods <= 0)
5465 5490                          return (EINVAL);
5466 5491  
5467 5492                  claimstr(stp->sd_wrq);
5468 5493                  q = stp->sd_wrq;
5469 5494                  for (i = 0; i < nmods && _SAMESTR(q); i++, q = q->q_next) {
5470 5495                          qname = Q2NAME(q->q_next);
5471 5496                          error = strcopyout(qname, &mlist[i], strlen(qname) + 1,
5472 5497                              copyflag);
5473 5498                          if (error != 0) {
5474 5499                                  releasestr(stp->sd_wrq);
5475 5500                                  return (error);
5476 5501                          }
5477 5502                  }
5478 5503                  releasestr(stp->sd_wrq);
5479 5504                  return (strcopyout(&i, (void *)arg, sizeof (int), copyflag));
5480 5505          }
5481 5506  
5482 5507          case I_CKBAND:
5483 5508          {
5484 5509                  queue_t *q;
5485 5510                  qband_t *qbp;
5486 5511  
5487 5512                  if ((arg < 0) || (arg >= NBAND))
5488 5513                          return (EINVAL);
5489 5514                  q = _RD(stp->sd_wrq);
5490 5515                  mutex_enter(QLOCK(q));
5491 5516                  if (arg > (int)q->q_nband) {
5492 5517                          *rvalp = 0;
5493 5518                  } else {
5494 5519                          if (arg == 0) {
5495 5520                                  if (q->q_first)
5496 5521                                          *rvalp = 1;
5497 5522                                  else
5498 5523                                          *rvalp = 0;
5499 5524                          } else {
5500 5525                                  qbp = q->q_bandp;
5501 5526                                  while (--arg > 0)
5502 5527                                          qbp = qbp->qb_next;
5503 5528                                  if (qbp->qb_first)
5504 5529                                          *rvalp = 1;
5505 5530                                  else
5506 5531                                          *rvalp = 0;
5507 5532                          }
5508 5533                  }
5509 5534                  mutex_exit(QLOCK(q));
5510 5535                  return (0);
5511 5536          }
5512 5537  
5513 5538          case I_GETBAND:
5514 5539          {
5515 5540                  int intpri;
5516 5541                  queue_t *q;
5517 5542  
5518 5543                  q = _RD(stp->sd_wrq);
5519 5544                  mutex_enter(QLOCK(q));
5520 5545                  mp = q->q_first;
5521 5546                  if (!mp) {
5522 5547                          mutex_exit(QLOCK(q));
5523 5548                          return (ENODATA);
5524 5549                  }
5525 5550                  intpri = (int)mp->b_band;
5526 5551                  error = strcopyout(&intpri, (void *)arg, sizeof (int),
5527 5552                      copyflag);
5528 5553                  mutex_exit(QLOCK(q));
5529 5554                  return (error);
5530 5555          }
5531 5556  
5532 5557          case I_ATMARK:
5533 5558          {
5534 5559                  queue_t *q;
5535 5560  
5536 5561                  if (arg & ~(ANYMARK|LASTMARK))
5537 5562                          return (EINVAL);
5538 5563                  q = _RD(stp->sd_wrq);
5539 5564                  mutex_enter(&stp->sd_lock);
5540 5565                  if ((stp->sd_flag & STRATMARK) && (arg == ANYMARK)) {
5541 5566                          *rvalp = 1;
5542 5567                  } else {
5543 5568                          mutex_enter(QLOCK(q));
5544 5569                          mp = q->q_first;
5545 5570  
5546 5571                          if (mp == NULL)
5547 5572                                  *rvalp = 0;
5548 5573                          else if ((arg == ANYMARK) && (mp->b_flag & MSGMARK))
5549 5574                                  *rvalp = 1;
5550 5575                          else if ((arg == LASTMARK) && (mp == stp->sd_mark))
5551 5576                                  *rvalp = 1;
5552 5577                          else
5553 5578                                  *rvalp = 0;
5554 5579                          mutex_exit(QLOCK(q));
5555 5580                  }
5556 5581                  mutex_exit(&stp->sd_lock);
5557 5582                  return (0);
5558 5583          }
5559 5584  
5560 5585          case I_CANPUT:
5561 5586          {
5562 5587                  char band;
5563 5588  
5564 5589                  if ((arg < 0) || (arg >= NBAND))
5565 5590                          return (EINVAL);
5566 5591                  band = (char)arg;
5567 5592                  *rvalp = bcanputnext(stp->sd_wrq, band);
5568 5593                  return (0);
5569 5594          }
5570 5595  
5571 5596          case I_SETCLTIME:
5572 5597          {
5573 5598                  int closetime;
5574 5599  
5575 5600                  error = strcopyin((void *)arg, &closetime, sizeof (int),
5576 5601                      copyflag);
5577 5602                  if (error)
5578 5603                          return (error);
5579 5604                  if (closetime < 0)
5580 5605                          return (EINVAL);
5581 5606  
5582 5607                  stp->sd_closetime = closetime;
5583 5608                  return (0);
5584 5609          }
5585 5610  
5586 5611          case I_GETCLTIME:
5587 5612          {
5588 5613                  int closetime;
5589 5614  
5590 5615                  closetime = stp->sd_closetime;
5591 5616                  return (strcopyout(&closetime, (void *)arg, sizeof (int),
5592 5617                      copyflag));
5593 5618          }
5594 5619  
5595 5620          case TIOCGSID:
5596 5621          {
5597 5622                  pid_t sid;
5598 5623  
5599 5624                  mutex_enter(&stp->sd_lock);
5600 5625                  if (stp->sd_sidp == NULL) {
5601 5626                          mutex_exit(&stp->sd_lock);
5602 5627                          return (ENOTTY);
5603 5628                  }
5604 5629                  sid = stp->sd_sidp->pid_id;
5605 5630                  mutex_exit(&stp->sd_lock);
5606 5631                  return (strcopyout(&sid, (void *)arg, sizeof (pid_t),
5607 5632                      copyflag));
5608 5633          }
5609 5634  
5610 5635          case TIOCSPGRP:
5611 5636          {
5612 5637                  pid_t pgrp;
5613 5638                  proc_t *q;
5614 5639                  pid_t   sid, fg_pgid, bg_pgid;
5615 5640  
5616 5641                  if (error = strcopyin((void *)arg, &pgrp, sizeof (pid_t),
5617 5642                      copyflag))
5618 5643                          return (error);
5619 5644                  mutex_enter(&stp->sd_lock);
5620 5645                  mutex_enter(&pidlock);
5621 5646                  if (stp->sd_sidp != ttoproc(curthread)->p_sessp->s_sidp) {
5622 5647                          mutex_exit(&pidlock);
5623 5648                          mutex_exit(&stp->sd_lock);
5624 5649                          return (ENOTTY);
5625 5650                  }
5626 5651                  if (pgrp == stp->sd_pgidp->pid_id) {
5627 5652                          mutex_exit(&pidlock);
5628 5653                          mutex_exit(&stp->sd_lock);
5629 5654                          return (0);
5630 5655                  }
5631 5656                  if (pgrp <= 0 || pgrp >= maxpid) {
5632 5657                          mutex_exit(&pidlock);
5633 5658                          mutex_exit(&stp->sd_lock);
5634 5659                          return (EINVAL);
5635 5660                  }
5636 5661                  if ((q = pgfind(pgrp)) == NULL ||
5637 5662                      q->p_sessp != ttoproc(curthread)->p_sessp) {
5638 5663                          mutex_exit(&pidlock);
5639 5664                          mutex_exit(&stp->sd_lock);
5640 5665                          return (EPERM);
5641 5666                  }
5642 5667                  sid = stp->sd_sidp->pid_id;
5643 5668                  fg_pgid = q->p_pgrp;
5644 5669                  bg_pgid = stp->sd_pgidp->pid_id;
5645 5670                  CL_SET_PROCESS_GROUP(curthread, sid, bg_pgid, fg_pgid);
5646 5671                  PID_RELE(stp->sd_pgidp);
5647 5672                  ctty_clear_sighuped();
5648 5673                  stp->sd_pgidp = q->p_pgidp;
5649 5674                  PID_HOLD(stp->sd_pgidp);
5650 5675                  mutex_exit(&pidlock);
5651 5676                  mutex_exit(&stp->sd_lock);
5652 5677                  return (0);
5653 5678          }
5654 5679  
5655 5680          case TIOCGPGRP:
5656 5681          {
5657 5682                  pid_t pgrp;
5658 5683  
5659 5684                  mutex_enter(&stp->sd_lock);
5660 5685                  if (stp->sd_sidp == NULL) {
5661 5686                          mutex_exit(&stp->sd_lock);
5662 5687                          return (ENOTTY);
5663 5688                  }
5664 5689                  pgrp = stp->sd_pgidp->pid_id;
5665 5690                  mutex_exit(&stp->sd_lock);
5666 5691                  return (strcopyout(&pgrp, (void *)arg, sizeof (pid_t),
5667 5692                      copyflag));
5668 5693          }
5669 5694  
5670 5695          case TIOCSCTTY:
5671 5696          {
5672 5697                  return (strctty(stp));
5673 5698          }
5674 5699  
5675 5700          case TIOCNOTTY:
5676 5701          {
5677 5702                  /* freectty() always assumes curproc. */
5678 5703                  if (freectty(B_FALSE) != 0)
5679 5704                          return (0);
5680 5705                  return (ENOTTY);
5681 5706          }
5682 5707  
5683 5708          case FIONBIO:
5684 5709          case FIOASYNC:
5685 5710                  return (0);     /* handled by the upper layer */
5686 5711          }
5687 5712  }
5688 5713  
5689 5714  /*
5690 5715   * Custom free routine used for M_PASSFP messages.
5691 5716   */
5692 5717  static void
5693 5718  free_passfp(struct k_strrecvfd *srf)
5694 5719  {
5695 5720          (void) closef(srf->fp);
5696 5721          kmem_free(srf, sizeof (struct k_strrecvfd) + sizeof (frtn_t));
5697 5722  }
5698 5723  
5699 5724  /* ARGSUSED */
5700 5725  int
5701 5726  do_sendfp(struct stdata *stp, struct file *fp, struct cred *cr)
5702 5727  {
5703 5728          queue_t *qp, *nextqp;
5704 5729          struct k_strrecvfd *srf;
5705 5730          mblk_t *mp;
5706 5731          frtn_t *frtnp;
5707 5732          size_t bufsize;
5708 5733          queue_t *mate = NULL;
5709 5734          syncq_t *sq = NULL;
5710 5735          int retval = 0;
5711 5736  
5712 5737          if (stp->sd_flag & STRHUP)
5713 5738                  return (ENXIO);
5714 5739  
5715 5740          claimstr(stp->sd_wrq);
5716 5741  
5717 5742          /* Fastpath, we have a pipe, and we are already mated, use it. */
5718 5743          if (STRMATED(stp)) {
5719 5744                  qp = _RD(stp->sd_mate->sd_wrq);
5720 5745                  claimstr(qp);
5721 5746                  mate = qp;
5722 5747          } else { /* Not already mated. */
5723 5748  
5724 5749                  /*
5725 5750                   * Walk the stream to the end of this one.
5726 5751                   * assumes that the claimstr() will prevent
5727 5752                   * plumbing between the stream head and the
5728 5753                   * driver from changing
5729 5754                   */
5730 5755                  qp = stp->sd_wrq;
5731 5756  
5732 5757                  /*
5733 5758                   * Loop until we reach the end of this stream.
5734 5759                   * On completion, qp points to the write queue
5735 5760                   * at the end of the stream, or the read queue
5736 5761                   * at the stream head if this is a fifo.
5737 5762                   */
5738 5763                  while (((qp = qp->q_next) != NULL) && _SAMESTR(qp))
5739 5764                          ;
5740 5765  
5741 5766                  /*
5742 5767                   * Just in case we get a q_next which is NULL, but
5743 5768                   * not at the end of the stream.  This is actually
5744 5769                   * broken, so we set an assert to catch it in
5745 5770                   * debug, and set an error and return if not debug.
5746 5771                   */
5747 5772                  ASSERT(qp);
5748 5773                  if (qp == NULL) {
5749 5774                          releasestr(stp->sd_wrq);
5750 5775                          return (EINVAL);
5751 5776                  }
5752 5777  
5753 5778                  /*
5754 5779                   * Enter the syncq for the driver, so (hopefully)
5755 5780                   * the queue values will not change on us.
5756 5781                   * XXXX - This will only prevent the race IFF only
5757 5782                   *   the write side modifies the q_next member, and
5758 5783                   *   the put procedure is protected by at least
5759 5784                   *   MT_PERQ.
5760 5785                   */
5761 5786                  if ((sq = qp->q_syncq) != NULL)
5762 5787                          entersq(sq, SQ_PUT);
5763 5788  
5764 5789                  /* Now get the q_next value from this qp. */
5765 5790                  nextqp = qp->q_next;
5766 5791  
5767 5792                  /*
5768 5793                   * If nextqp exists and the other stream is different
5769 5794                   * from this one claim the stream, set the mate, and
5770 5795                   * get the read queue at the stream head of the other
5771 5796                   * stream.  Assumes that nextqp was at least valid when
5772 5797                   * we got it.  Hopefully the entersq of the driver
5773 5798                   * will prevent it from changing on us.
5774 5799                   */
5775 5800                  if ((nextqp != NULL) && (STREAM(nextqp) != stp)) {
5776 5801                          ASSERT(qp->q_qinfo->qi_srvp);
5777 5802                          ASSERT(_OTHERQ(qp)->q_qinfo->qi_srvp);
5778 5803                          ASSERT(_OTHERQ(qp->q_next)->q_qinfo->qi_srvp);
5779 5804                          claimstr(nextqp);
5780 5805  
5781 5806                          /* Make sure we still have a q_next */
5782 5807                          if (nextqp != qp->q_next) {
5783 5808                                  releasestr(stp->sd_wrq);
5784 5809                                  releasestr(nextqp);
5785 5810                                  return (EINVAL);
5786 5811                          }
5787 5812  
5788 5813                          qp = _RD(STREAM(nextqp)->sd_wrq);
5789 5814                          mate = qp;
5790 5815                  }
5791 5816                  /* If we entered the synq above, leave it. */
5792 5817                  if (sq != NULL)
5793 5818                          leavesq(sq, SQ_PUT);
5794 5819          } /*  STRMATED(STP)  */
5795 5820  
5796 5821          /* XXX prevents substitution of the ops vector */
5797 5822          if (qp->q_qinfo != &strdata && qp->q_qinfo != &fifo_strdata) {
5798 5823                  retval = EINVAL;
5799 5824                  goto out;
5800 5825          }
5801 5826  
5802 5827          if (qp->q_flag & QFULL) {
5803 5828                  retval = EAGAIN;
5804 5829                  goto out;
5805 5830          }
5806 5831  
5807 5832          /*
5808 5833           * Since M_PASSFP messages include a file descriptor, we use
5809 5834           * esballoc() and specify a custom free routine (free_passfp()) that
5810 5835           * will close the descriptor as part of freeing the message.  For
5811 5836           * convenience, we stash the frtn_t right after the data block.
5812 5837           */
5813 5838          bufsize = sizeof (struct k_strrecvfd) + sizeof (frtn_t);
5814 5839          srf = kmem_alloc(bufsize, KM_NOSLEEP);
5815 5840          if (srf == NULL) {
5816 5841                  retval = EAGAIN;
5817 5842                  goto out;
5818 5843          }
5819 5844  
5820 5845          frtnp = (frtn_t *)(srf + 1);
5821 5846          frtnp->free_arg = (caddr_t)srf;
5822 5847          frtnp->free_func = free_passfp;
5823 5848  
5824 5849          mp = esballoc((uchar_t *)srf, bufsize, BPRI_MED, frtnp);
5825 5850          if (mp == NULL) {
5826 5851                  kmem_free(srf, bufsize);
5827 5852                  retval = EAGAIN;
5828 5853                  goto out;
5829 5854          }
5830 5855          mp->b_wptr += sizeof (struct k_strrecvfd);
5831 5856          mp->b_datap->db_type = M_PASSFP;
5832 5857  
5833 5858          srf->fp = fp;
5834 5859          srf->uid = crgetuid(curthread->t_cred);
5835 5860          srf->gid = crgetgid(curthread->t_cred);
5836 5861          mutex_enter(&fp->f_tlock);
5837 5862          fp->f_count++;
5838 5863          mutex_exit(&fp->f_tlock);
5839 5864  
5840 5865          put(qp, mp);
5841 5866  out:
5842 5867          releasestr(stp->sd_wrq);
5843 5868          if (mate)
5844 5869                  releasestr(mate);
5845 5870          return (retval);
5846 5871  }
5847 5872  
5848 5873  /*
5849 5874   * Send an ioctl message downstream and wait for acknowledgement.
5850 5875   * flags may be set to either U_TO_K or K_TO_K and a combination
5851 5876   * of STR_NOERROR or STR_NOSIG
5852 5877   * STR_NOSIG: Signals are essentially ignored or held and have
5853 5878   *      no effect for the duration of the call.
5854 5879   * STR_NOERROR: Ignores stream head read, write and hup errors.
5855 5880   *      Additionally, if an existing ioctl times out, it is assumed
5856 5881   *      lost and and this ioctl will continue as if the previous ioctl had
5857 5882   *      finished.  ETIME may be returned if this ioctl times out (i.e.
5858 5883   *      ic_timout is not INFTIM).  Non-stream head errors may be returned if
5859 5884   *      the ioc_error indicates that the driver/module had problems,
5860 5885   *      an EFAULT was found when accessing user data, a lack of
5861 5886   *      resources, etc.
5862 5887   */
5863 5888  int
5864 5889  strdoioctl(
5865 5890          struct stdata *stp,
5866 5891          struct strioctl *strioc,
5867 5892          int fflags,             /* file flags with model info */
5868 5893          int flag,
5869 5894          cred_t *crp,
5870 5895          int *rvalp)
5871 5896  {
5872 5897          mblk_t *bp;
5873 5898          struct iocblk *iocbp;
5874 5899          struct copyreq *reqp;
5875 5900          struct copyresp *resp;
5876 5901          int id;
5877 5902          int transparent = 0;
5878 5903          int error = 0;
5879 5904          int len = 0;
5880 5905          caddr_t taddr;
5881 5906          int copyflag = (flag & (U_TO_K | K_TO_K));
5882 5907          int sigflag = (flag & STR_NOSIG);
5883 5908          int errs;
5884 5909          uint_t waitflags;
5885 5910          boolean_t set_iocwaitne = B_FALSE;
5886 5911  
5887 5912          ASSERT(copyflag == U_TO_K || copyflag == K_TO_K);
5888 5913          ASSERT((fflags & FMODELS) != 0);
5889 5914  
5890 5915          TRACE_2(TR_FAC_STREAMS_FR,
5891 5916              TR_STRDOIOCTL,
5892 5917              "strdoioctl:stp %p strioc %p", stp, strioc);
5893 5918          if (strioc->ic_len == TRANSPARENT) {    /* send arg in M_DATA block */
5894 5919                  transparent = 1;
5895 5920                  strioc->ic_len = sizeof (intptr_t);
5896 5921          }
5897 5922  
5898 5923          if (strioc->ic_len < 0 || (strmsgsz > 0 && strioc->ic_len > strmsgsz))
5899 5924                  return (EINVAL);
5900 5925  
5901 5926          if ((bp = allocb_cred_wait(sizeof (union ioctypes), sigflag, &error,
5902 5927              crp, curproc->p_pid)) == NULL)
5903 5928                          return (error);
5904 5929  
5905 5930          bzero(bp->b_wptr, sizeof (union ioctypes));
5906 5931  
5907 5932          iocbp = (struct iocblk *)bp->b_wptr;
5908 5933          iocbp->ioc_count = strioc->ic_len;
5909 5934          iocbp->ioc_cmd = strioc->ic_cmd;
5910 5935          iocbp->ioc_flag = (fflags & FMODELS);
5911 5936  
5912 5937          crhold(crp);
5913 5938          iocbp->ioc_cr = crp;
5914 5939          DB_TYPE(bp) = M_IOCTL;
5915 5940          bp->b_wptr += sizeof (struct iocblk);
5916 5941  
5917 5942          if (flag & STR_NOERROR)
5918 5943                  errs = STPLEX;
5919 5944          else
5920 5945                  errs = STRHUP|STRDERR|STWRERR|STPLEX;
5921 5946  
5922 5947          /*
5923 5948           * If there is data to copy into ioctl block, do so.
5924 5949           */
5925 5950          if (iocbp->ioc_count > 0) {
5926 5951                  if (transparent)
5927 5952                          /*
5928 5953                           * Note: STR_NOERROR does not have an effect
5929 5954                           * in putiocd()
5930 5955                           */
5931 5956                          id = K_TO_K | sigflag;
5932 5957                  else
5933 5958                          id = flag;
5934 5959                  if ((error = putiocd(bp, strioc->ic_dp, id, crp)) != 0) {
5935 5960                          freemsg(bp);
5936 5961                          crfree(crp);
5937 5962                          return (error);
5938 5963                  }
5939 5964  
5940 5965                  /*
5941 5966                   * We could have slept copying in user pages.
5942 5967                   * Recheck the stream head state (the other end
5943 5968                   * of a pipe could have gone away).
5944 5969                   */
5945 5970                  if (stp->sd_flag & errs) {
5946 5971                          mutex_enter(&stp->sd_lock);
5947 5972                          error = strgeterr(stp, errs, 0);
5948 5973                          mutex_exit(&stp->sd_lock);
5949 5974                          if (error != 0) {
5950 5975                                  freemsg(bp);
5951 5976                                  crfree(crp);
5952 5977                                  return (error);
5953 5978                          }
5954 5979                  }
5955 5980          }
5956 5981          if (transparent)
5957 5982                  iocbp->ioc_count = TRANSPARENT;
5958 5983  
5959 5984          /*
5960 5985           * Block for up to STRTIMOUT milliseconds if there is an outstanding
5961 5986           * ioctl for this stream already running.  All processes
5962 5987           * sleeping here will be awakened as a result of an ACK
5963 5988           * or NAK being received for the outstanding ioctl, or
5964 5989           * as a result of the timer expiring on the outstanding
5965 5990           * ioctl (a failure), or as a result of any waiting
5966 5991           * process's timer expiring (also a failure).
5967 5992           */
5968 5993  
5969 5994          error = 0;
5970 5995          mutex_enter(&stp->sd_lock);
5971 5996          while ((stp->sd_flag & IOCWAIT) ||
5972 5997              (!set_iocwaitne && (stp->sd_flag & IOCWAITNE))) {
5973 5998                  clock_t cv_rval;
5974 5999  
5975 6000                  TRACE_0(TR_FAC_STREAMS_FR,
5976 6001                      TR_STRDOIOCTL_WAIT,
5977 6002                      "strdoioctl sleeps - IOCWAIT");
5978 6003                  cv_rval = str_cv_wait(&stp->sd_iocmonitor, &stp->sd_lock,
5979 6004                      STRTIMOUT, sigflag);
5980 6005                  if (cv_rval <= 0) {
5981 6006                          if (cv_rval == 0) {
5982 6007                                  error = EINTR;
5983 6008                          } else {
5984 6009                                  if (flag & STR_NOERROR) {
5985 6010                                          /*
5986 6011                                           * Terminating current ioctl in
5987 6012                                           * progress -- assume it got lost and
5988 6013                                           * wake up the other thread so that the
5989 6014                                           * operation completes.
5990 6015                                           */
5991 6016                                          if (!(stp->sd_flag & IOCWAITNE)) {
5992 6017                                                  set_iocwaitne = B_TRUE;
5993 6018                                                  stp->sd_flag |= IOCWAITNE;
5994 6019                                                  cv_broadcast(&stp->sd_monitor);
5995 6020                                          }
5996 6021                                          /*
5997 6022                                           * Otherwise, there's a running
5998 6023                                           * STR_NOERROR -- we have no choice
5999 6024                                           * here but to wait forever (or until
6000 6025                                           * interrupted).
6001 6026                                           */
6002 6027                                  } else {
6003 6028                                          /*
6004 6029                                           * pending ioctl has caused
6005 6030                                           * us to time out
6006 6031                                           */
6007 6032                                          error = ETIME;
6008 6033                                  }
6009 6034                          }
6010 6035                  } else if ((stp->sd_flag & errs)) {
6011 6036                          error = strgeterr(stp, errs, 0);
6012 6037                  }
6013 6038                  if (error) {
6014 6039                          mutex_exit(&stp->sd_lock);
6015 6040                          freemsg(bp);
6016 6041                          crfree(crp);
6017 6042                          return (error);
6018 6043                  }
6019 6044          }
6020 6045  
6021 6046          /*
6022 6047           * Have control of ioctl mechanism.
6023 6048           * Send down ioctl packet and wait for response.
6024 6049           */
6025 6050          if (stp->sd_iocblk != (mblk_t *)-1) {
6026 6051                  freemsg(stp->sd_iocblk);
6027 6052          }
6028 6053          stp->sd_iocblk = NULL;
6029 6054  
6030 6055          /*
6031 6056           * If this is marked with 'noerror' (internal; mostly
6032 6057           * I_{P,}{UN,}LINK), then make sure nobody else is able to get
6033 6058           * in here by setting IOCWAITNE.
6034 6059           */
6035 6060          waitflags = IOCWAIT;
6036 6061          if (flag & STR_NOERROR)
6037 6062                  waitflags |= IOCWAITNE;
6038 6063  
6039 6064          stp->sd_flag |= waitflags;
6040 6065  
6041 6066          /*
6042 6067           * Assign sequence number.
6043 6068           */
6044 6069          iocbp->ioc_id = stp->sd_iocid = getiocseqno();
6045 6070  
6046 6071          mutex_exit(&stp->sd_lock);
6047 6072  
6048 6073          TRACE_1(TR_FAC_STREAMS_FR,
6049 6074              TR_STRDOIOCTL_PUT, "strdoioctl put: stp %p", stp);
6050 6075          stream_willservice(stp);
6051 6076          putnext(stp->sd_wrq, bp);
6052 6077          stream_runservice(stp);
6053 6078  
6054 6079          /*
6055 6080           * Timed wait for acknowledgment.  The wait time is limited by the
6056 6081           * timeout value, which must be a positive integer (number of
6057 6082           * milliseconds) to wait, or 0 (use default value of STRTIMOUT
6058 6083           * milliseconds), or -1 (wait forever).  This will be awakened
6059 6084           * either by an ACK/NAK message arriving, the timer expiring, or
6060 6085           * the timer expiring on another ioctl waiting for control of the
6061 6086           * mechanism.
6062 6087           */
6063 6088  waitioc:
6064 6089          mutex_enter(&stp->sd_lock);
6065 6090  
6066 6091  
6067 6092          /*
6068 6093           * If the reply has already arrived, don't sleep.  If awakened from
6069 6094           * the sleep, fail only if the reply has not arrived by then.
6070 6095           * Otherwise, process the reply.
6071 6096           */
6072 6097          while (!stp->sd_iocblk) {
6073 6098                  clock_t cv_rval;
6074 6099  
6075 6100                  if (stp->sd_flag & errs) {
6076 6101                          error = strgeterr(stp, errs, 0);
6077 6102                          if (error != 0) {
6078 6103                                  stp->sd_flag &= ~waitflags;
6079 6104                                  cv_broadcast(&stp->sd_iocmonitor);
6080 6105                                  mutex_exit(&stp->sd_lock);
6081 6106                                  crfree(crp);
6082 6107                                  return (error);
6083 6108                          }
6084 6109                  }
6085 6110  
6086 6111                  TRACE_0(TR_FAC_STREAMS_FR,
6087 6112                      TR_STRDOIOCTL_WAIT2,
6088 6113                      "strdoioctl sleeps awaiting reply");
6089 6114                  ASSERT(error == 0);
6090 6115  
6091 6116                  cv_rval = str_cv_wait(&stp->sd_monitor, &stp->sd_lock,
6092 6117                      (strioc->ic_timout ?
6093 6118                      strioc->ic_timout * 1000 : STRTIMOUT), sigflag);
6094 6119  
6095 6120                  /*
6096 6121                   * There are four possible cases here: interrupt, timeout,
6097 6122                   * wakeup by IOCWAITNE (above), or wakeup by strrput_nondata (a
6098 6123                   * valid M_IOCTL reply).
6099 6124                   *
6100 6125                   * If we've been awakened by a STR_NOERROR ioctl on some other
6101 6126                   * thread, then sd_iocblk will still be NULL, and IOCWAITNE
6102 6127                   * will be set.  Pretend as if we just timed out.  Note that
6103 6128                   * this other thread waited at least STRTIMOUT before trying to
6104 6129                   * awaken our thread, so this is indistinguishable (even for
6105 6130                   * INFTIM) from the case where we failed with ETIME waiting on
6106 6131                   * IOCWAIT in the prior loop.
6107 6132                   */
6108 6133                  if (cv_rval > 0 && !(flag & STR_NOERROR) &&
6109 6134                      stp->sd_iocblk == NULL && (stp->sd_flag & IOCWAITNE)) {
6110 6135                          cv_rval = -1;
6111 6136                  }
6112 6137  
6113 6138                  /*
6114 6139                   * note: STR_NOERROR does not protect
6115 6140                   * us here.. use ic_timout < 0
6116 6141                   */
6117 6142                  if (cv_rval <= 0) {
6118 6143                          if (cv_rval == 0) {
6119 6144                                  error = EINTR;
6120 6145                          } else {
6121 6146                                  error =  ETIME;
6122 6147                          }
6123 6148                          /*
6124 6149                           * A message could have come in after we were scheduled
6125 6150                           * but before we were actually run.
6126 6151                           */
6127 6152                          bp = stp->sd_iocblk;
6128 6153                          stp->sd_iocblk = NULL;
6129 6154                          if (bp != NULL) {
6130 6155                                  if ((bp->b_datap->db_type == M_COPYIN) ||
6131 6156                                      (bp->b_datap->db_type == M_COPYOUT)) {
6132 6157                                          mutex_exit(&stp->sd_lock);
6133 6158                                          if (bp->b_cont) {
6134 6159                                                  freemsg(bp->b_cont);
6135 6160                                                  bp->b_cont = NULL;
6136 6161                                          }
6137 6162                                          bp->b_datap->db_type = M_IOCDATA;
6138 6163                                          bp->b_wptr = bp->b_rptr +
6139 6164                                              sizeof (struct copyresp);
6140 6165                                          resp = (struct copyresp *)bp->b_rptr;
6141 6166                                          resp->cp_rval =
6142 6167                                              (caddr_t)1; /* failure */
6143 6168                                          stream_willservice(stp);
6144 6169                                          putnext(stp->sd_wrq, bp);
6145 6170                                          stream_runservice(stp);
6146 6171                                          mutex_enter(&stp->sd_lock);
6147 6172                                  } else {
6148 6173                                          freemsg(bp);
6149 6174                                  }
6150 6175                          }
6151 6176                          stp->sd_flag &= ~waitflags;
6152 6177                          cv_broadcast(&stp->sd_iocmonitor);
6153 6178                          mutex_exit(&stp->sd_lock);
6154 6179                          crfree(crp);
6155 6180                          return (error);
6156 6181                  }
6157 6182          }
6158 6183          bp = stp->sd_iocblk;
6159 6184          /*
6160 6185           * Note: it is strictly impossible to get here with sd_iocblk set to
6161 6186           * -1.  This is because the initial loop above doesn't allow any new
6162 6187           * ioctls into the fray until all others have passed this point.
6163 6188           */
6164 6189          ASSERT(bp != NULL && bp != (mblk_t *)-1);
6165 6190          TRACE_1(TR_FAC_STREAMS_FR,
6166 6191              TR_STRDOIOCTL_ACK, "strdoioctl got reply: bp %p", bp);
6167 6192          if ((bp->b_datap->db_type == M_IOCACK) ||
6168 6193              (bp->b_datap->db_type == M_IOCNAK)) {
6169 6194                  /* for detection of duplicate ioctl replies */
6170 6195                  stp->sd_iocblk = (mblk_t *)-1;
6171 6196                  stp->sd_flag &= ~waitflags;
6172 6197                  cv_broadcast(&stp->sd_iocmonitor);
6173 6198                  mutex_exit(&stp->sd_lock);
6174 6199          } else {
6175 6200                  /*
6176 6201                   * flags not cleared here because we're still doing
6177 6202                   * copy in/out for ioctl.
6178 6203                   */
6179 6204                  stp->sd_iocblk = NULL;
6180 6205                  mutex_exit(&stp->sd_lock);
6181 6206          }
6182 6207  
6183 6208  
6184 6209          /*
6185 6210           * Have received acknowledgment.
6186 6211           */
6187 6212  
6188 6213          switch (bp->b_datap->db_type) {
6189 6214          case M_IOCACK:
6190 6215                  /*
6191 6216                   * Positive ack.
6192 6217                   */
6193 6218                  iocbp = (struct iocblk *)bp->b_rptr;
6194 6219  
6195 6220                  /*
6196 6221                   * Set error if indicated.
6197 6222                   */
6198 6223                  if (iocbp->ioc_error) {
6199 6224                          error = iocbp->ioc_error;
6200 6225                          break;
6201 6226                  }
6202 6227  
6203 6228                  /*
6204 6229                   * Set return value.
6205 6230                   */
6206 6231                  *rvalp = iocbp->ioc_rval;
6207 6232  
6208 6233                  /*
6209 6234                   * Data may have been returned in ACK message (ioc_count > 0).
6210 6235                   * If so, copy it out to the user's buffer.
6211 6236                   */
6212 6237                  if (iocbp->ioc_count && !transparent) {
6213 6238                          if (error = getiocd(bp, strioc->ic_dp, copyflag))
6214 6239                                  break;
6215 6240                  }
6216 6241                  if (!transparent) {
6217 6242                          if (len)        /* an M_COPYOUT was used with I_STR */
6218 6243                                  strioc->ic_len = len;
6219 6244                          else
6220 6245                                  strioc->ic_len = (int)iocbp->ioc_count;
6221 6246                  }
6222 6247                  break;
6223 6248  
6224 6249          case M_IOCNAK:
6225 6250                  /*
6226 6251                   * Negative ack.
6227 6252                   *
6228 6253                   * The only thing to do is set error as specified
6229 6254                   * in neg ack packet.
6230 6255                   */
6231 6256                  iocbp = (struct iocblk *)bp->b_rptr;
6232 6257  
6233 6258                  error = (iocbp->ioc_error ? iocbp->ioc_error : EINVAL);
6234 6259                  break;
6235 6260  
6236 6261          case M_COPYIN:
6237 6262                  /*
6238 6263                   * Driver or module has requested user ioctl data.
6239 6264                   */
6240 6265                  reqp = (struct copyreq *)bp->b_rptr;
6241 6266  
6242 6267                  /*
6243 6268                   * M_COPYIN should *never* have a message attached, though
6244 6269                   * it's harmless if it does -- thus, panic on a DEBUG
6245 6270                   * kernel and just free it on a non-DEBUG build.
6246 6271                   */
6247 6272                  ASSERT(bp->b_cont == NULL);
6248 6273                  if (bp->b_cont != NULL) {
6249 6274                          freemsg(bp->b_cont);
6250 6275                          bp->b_cont = NULL;
6251 6276                  }
6252 6277  
6253 6278                  error = putiocd(bp, reqp->cq_addr, flag, crp);
6254 6279                  if (error && bp->b_cont) {
6255 6280                          freemsg(bp->b_cont);
6256 6281                          bp->b_cont = NULL;
6257 6282                  }
6258 6283  
6259 6284                  bp->b_wptr = bp->b_rptr + sizeof (struct copyresp);
6260 6285                  bp->b_datap->db_type = M_IOCDATA;
6261 6286  
6262 6287                  mblk_setcred(bp, crp, curproc->p_pid);
6263 6288                  resp = (struct copyresp *)bp->b_rptr;
6264 6289                  resp->cp_rval = (caddr_t)(uintptr_t)error;
6265 6290                  resp->cp_flag = (fflags & FMODELS);
6266 6291  
6267 6292                  stream_willservice(stp);
6268 6293                  putnext(stp->sd_wrq, bp);
6269 6294                  stream_runservice(stp);
6270 6295  
6271 6296                  if (error) {
6272 6297                          mutex_enter(&stp->sd_lock);
6273 6298                          stp->sd_flag &= ~waitflags;
6274 6299                          cv_broadcast(&stp->sd_iocmonitor);
6275 6300                          mutex_exit(&stp->sd_lock);
6276 6301                          crfree(crp);
6277 6302                          return (error);
6278 6303                  }
6279 6304  
6280 6305                  goto waitioc;
6281 6306  
6282 6307          case M_COPYOUT:
6283 6308                  /*
6284 6309                   * Driver or module has ioctl data for a user.
6285 6310                   */
6286 6311                  reqp = (struct copyreq *)bp->b_rptr;
6287 6312                  ASSERT(bp->b_cont != NULL);
6288 6313  
6289 6314                  /*
6290 6315                   * Always (transparent or non-transparent )
6291 6316                   * use the address specified in the request
6292 6317                   */
6293 6318                  taddr = reqp->cq_addr;
6294 6319                  if (!transparent)
6295 6320                          len = (int)reqp->cq_size;
6296 6321  
6297 6322                  /* copyout data to the provided address */
6298 6323                  error = getiocd(bp, taddr, copyflag);
6299 6324  
6300 6325                  freemsg(bp->b_cont);
6301 6326                  bp->b_cont = NULL;
6302 6327  
6303 6328                  bp->b_wptr = bp->b_rptr + sizeof (struct copyresp);
6304 6329                  bp->b_datap->db_type = M_IOCDATA;
6305 6330  
6306 6331                  mblk_setcred(bp, crp, curproc->p_pid);
6307 6332                  resp = (struct copyresp *)bp->b_rptr;
6308 6333                  resp->cp_rval = (caddr_t)(uintptr_t)error;
6309 6334                  resp->cp_flag = (fflags & FMODELS);
6310 6335  
6311 6336                  stream_willservice(stp);
6312 6337                  putnext(stp->sd_wrq, bp);
6313 6338                  stream_runservice(stp);
6314 6339  
6315 6340                  if (error) {
6316 6341                          mutex_enter(&stp->sd_lock);
6317 6342                          stp->sd_flag &= ~waitflags;
6318 6343                          cv_broadcast(&stp->sd_iocmonitor);
6319 6344                          mutex_exit(&stp->sd_lock);
6320 6345                          crfree(crp);
6321 6346                          return (error);
6322 6347                  }
6323 6348                  goto waitioc;
6324 6349  
6325 6350          default:
6326 6351                  ASSERT(0);
6327 6352                  mutex_enter(&stp->sd_lock);
6328 6353                  stp->sd_flag &= ~waitflags;
6329 6354                  cv_broadcast(&stp->sd_iocmonitor);
6330 6355                  mutex_exit(&stp->sd_lock);
6331 6356                  break;
6332 6357          }
6333 6358  
6334 6359          freemsg(bp);
6335 6360          crfree(crp);
6336 6361          return (error);
6337 6362  }
6338 6363  
6339 6364  /*
6340 6365   * Send an M_CMD message downstream and wait for a reply.  This is a ptools
6341 6366   * special used to retrieve information from modules/drivers a stream without
6342 6367   * being subjected to flow control or interfering with pending messages on the
6343 6368   * stream (e.g. an ioctl in flight).
6344 6369   */
6345 6370  int
6346 6371  strdocmd(struct stdata *stp, struct strcmd *scp, cred_t *crp)
6347 6372  {
6348 6373          mblk_t *mp;
6349 6374          struct cmdblk *cmdp;
6350 6375          int error = 0;
6351 6376          int errs = STRHUP|STRDERR|STWRERR|STPLEX;
6352 6377          clock_t rval, timeout = STRTIMOUT;
6353 6378  
6354 6379          if (scp->sc_len < 0 || scp->sc_len > sizeof (scp->sc_buf) ||
6355 6380              scp->sc_timeout < -1)
6356 6381                  return (EINVAL);
6357 6382  
6358 6383          if (scp->sc_timeout > 0)
6359 6384                  timeout = scp->sc_timeout * MILLISEC;
6360 6385  
6361 6386          if ((mp = allocb_cred(sizeof (struct cmdblk), crp,
6362 6387              curproc->p_pid)) == NULL)
6363 6388                  return (ENOMEM);
6364 6389  
6365 6390          crhold(crp);
6366 6391  
6367 6392          cmdp = (struct cmdblk *)mp->b_wptr;
6368 6393          cmdp->cb_cr = crp;
6369 6394          cmdp->cb_cmd = scp->sc_cmd;
6370 6395          cmdp->cb_len = scp->sc_len;
6371 6396          cmdp->cb_error = 0;
6372 6397          mp->b_wptr += sizeof (struct cmdblk);
6373 6398  
6374 6399          DB_TYPE(mp) = M_CMD;
6375 6400          DB_CPID(mp) = curproc->p_pid;
6376 6401  
6377 6402          /*
6378 6403           * Copy in the payload.
6379 6404           */
6380 6405          if (cmdp->cb_len > 0) {
6381 6406                  mp->b_cont = allocb_cred(sizeof (scp->sc_buf), crp,
6382 6407                      curproc->p_pid);
6383 6408                  if (mp->b_cont == NULL) {
6384 6409                          error = ENOMEM;
6385 6410                          goto out;
6386 6411                  }
6387 6412  
6388 6413                  /* cb_len comes from sc_len, which has already been checked */
6389 6414                  ASSERT(cmdp->cb_len <= sizeof (scp->sc_buf));
6390 6415                  (void) bcopy(scp->sc_buf, mp->b_cont->b_wptr, cmdp->cb_len);
6391 6416                  mp->b_cont->b_wptr += cmdp->cb_len;
6392 6417                  DB_CPID(mp->b_cont) = curproc->p_pid;
6393 6418          }
6394 6419  
6395 6420          /*
6396 6421           * Since this mechanism is strictly for ptools, and since only one
6397 6422           * process can be grabbed at a time, we simply fail if there's
6398 6423           * currently an operation pending.
6399 6424           */
6400 6425          mutex_enter(&stp->sd_lock);
6401 6426          if (stp->sd_flag & STRCMDWAIT) {
6402 6427                  mutex_exit(&stp->sd_lock);
6403 6428                  error = EBUSY;
6404 6429                  goto out;
6405 6430          }
6406 6431          stp->sd_flag |= STRCMDWAIT;
6407 6432          ASSERT(stp->sd_cmdblk == NULL);
6408 6433          mutex_exit(&stp->sd_lock);
6409 6434  
6410 6435          putnext(stp->sd_wrq, mp);
6411 6436          mp = NULL;
6412 6437  
6413 6438          /*
6414 6439           * Timed wait for acknowledgment.  If the reply has already arrived,
6415 6440           * don't sleep.  If awakened from the sleep, fail only if the reply
6416 6441           * has not arrived by then.  Otherwise, process the reply.
6417 6442           */
6418 6443          mutex_enter(&stp->sd_lock);
6419 6444          while (stp->sd_cmdblk == NULL) {
6420 6445                  if (stp->sd_flag & errs) {
6421 6446                          if ((error = strgeterr(stp, errs, 0)) != 0)
6422 6447                                  goto waitout;
6423 6448                  }
6424 6449  
6425 6450                  rval = str_cv_wait(&stp->sd_monitor, &stp->sd_lock, timeout, 0);
6426 6451                  if (stp->sd_cmdblk != NULL)
6427 6452                          break;
6428 6453  
6429 6454                  if (rval <= 0) {
6430 6455                          error = (rval == 0) ? EINTR : ETIME;
6431 6456                          goto waitout;
6432 6457                  }
6433 6458          }
6434 6459  
6435 6460          /*
6436 6461           * We received a reply.
6437 6462           */
6438 6463          mp = stp->sd_cmdblk;
6439 6464          stp->sd_cmdblk = NULL;
6440 6465          ASSERT(mp != NULL && DB_TYPE(mp) == M_CMD);
6441 6466          ASSERT(stp->sd_flag & STRCMDWAIT);
6442 6467          stp->sd_flag &= ~STRCMDWAIT;
6443 6468          mutex_exit(&stp->sd_lock);
6444 6469  
6445 6470          cmdp = (struct cmdblk *)mp->b_rptr;
6446 6471          if ((error = cmdp->cb_error) != 0)
6447 6472                  goto out;
6448 6473  
6449 6474          /*
6450 6475           * Data may have been returned in the reply (cb_len > 0).
6451 6476           * If so, copy it out to the user's buffer.
6452 6477           */
6453 6478          if (cmdp->cb_len > 0) {
6454 6479                  if (mp->b_cont == NULL || MBLKL(mp->b_cont) < cmdp->cb_len) {
6455 6480                          error = EPROTO;
6456 6481                          goto out;
6457 6482                  }
6458 6483  
6459 6484                  cmdp->cb_len = MIN(cmdp->cb_len, sizeof (scp->sc_buf));
6460 6485                  (void) bcopy(mp->b_cont->b_rptr, scp->sc_buf, cmdp->cb_len);
6461 6486          }
6462 6487          scp->sc_len = cmdp->cb_len;
6463 6488  out:
6464 6489          freemsg(mp);
6465 6490          crfree(crp);
6466 6491          return (error);
6467 6492  waitout:
6468 6493          ASSERT(stp->sd_cmdblk == NULL);
6469 6494          stp->sd_flag &= ~STRCMDWAIT;
6470 6495          mutex_exit(&stp->sd_lock);
6471 6496          crfree(crp);
6472 6497          return (error);
6473 6498  }
6474 6499  
6475 6500  /*
6476 6501   * For the SunOS keyboard driver.
6477 6502   * Return the next available "ioctl" sequence number.
6478 6503   * Exported, so that streams modules can send "ioctl" messages
6479 6504   * downstream from their open routine.
6480 6505   */
6481 6506  int
6482 6507  getiocseqno(void)
6483 6508  {
6484 6509          int     i;
6485 6510  
6486 6511          mutex_enter(&strresources);
6487 6512          i = ++ioc_id;
6488 6513          mutex_exit(&strresources);
6489 6514          return (i);
6490 6515  }
6491 6516  
6492 6517  /*
6493 6518   * Get the next message from the read queue.  If the message is
6494 6519   * priority, STRPRI will have been set by strrput().  This flag
6495 6520   * should be reset only when the entire message at the front of the
6496 6521   * queue as been consumed.
6497 6522   *
6498 6523   * NOTE: strgetmsg and kstrgetmsg have much of the logic in common.
6499 6524   */
6500 6525  int
6501 6526  strgetmsg(
6502 6527          struct vnode *vp,
6503 6528          struct strbuf *mctl,
6504 6529          struct strbuf *mdata,
6505 6530          unsigned char *prip,
6506 6531          int *flagsp,
6507 6532          int fmode,
6508 6533          rval_t *rvp)
6509 6534  {
6510 6535          struct stdata *stp;
6511 6536          mblk_t *bp, *nbp;
6512 6537          mblk_t *savemp = NULL;
6513 6538          mblk_t *savemptail = NULL;
6514 6539          uint_t old_sd_flag;
6515 6540          int flg;
6516 6541          int more = 0;
6517 6542          int error = 0;
6518 6543          char first = 1;
6519 6544          uint_t mark;            /* Contains MSG*MARK and _LASTMARK */
6520 6545  #define _LASTMARK       0x8000  /* Distinct from MSG*MARK */
6521 6546          unsigned char pri = 0;
6522 6547          queue_t *q;
6523 6548          int     pr = 0;                 /* Partial read successful */
6524 6549          struct uio uios;
6525 6550          struct uio *uiop = &uios;
6526 6551          struct iovec iovs;
6527 6552          unsigned char type;
6528 6553  
6529 6554          TRACE_1(TR_FAC_STREAMS_FR, TR_STRGETMSG_ENTER,
6530 6555              "strgetmsg:%p", vp);
6531 6556  
6532 6557          ASSERT(vp->v_stream);
6533 6558          stp = vp->v_stream;
6534 6559          rvp->r_val1 = 0;
6535 6560  
6536 6561          mutex_enter(&stp->sd_lock);
6537 6562  
6538 6563          if ((error = i_straccess(stp, JCREAD)) != 0) {
6539 6564                  mutex_exit(&stp->sd_lock);
6540 6565                  return (error);
6541 6566          }
6542 6567  
6543 6568          if (stp->sd_flag & (STRDERR|STPLEX)) {
6544 6569                  error = strgeterr(stp, STRDERR|STPLEX, 0);
6545 6570                  if (error != 0) {
6546 6571                          mutex_exit(&stp->sd_lock);
6547 6572                          return (error);
6548 6573                  }
6549 6574          }
6550 6575          mutex_exit(&stp->sd_lock);
6551 6576  
6552 6577          switch (*flagsp) {
6553 6578          case MSG_HIPRI:
6554 6579                  if (*prip != 0)
6555 6580                          return (EINVAL);
6556 6581                  break;
6557 6582  
6558 6583          case MSG_ANY:
6559 6584          case MSG_BAND:
6560 6585                  break;
6561 6586  
6562 6587          default:
6563 6588                  return (EINVAL);
6564 6589          }
6565 6590          /*
6566 6591           * Setup uio and iov for data part
6567 6592           */
6568 6593          iovs.iov_base = mdata->buf;
6569 6594          iovs.iov_len = mdata->maxlen;
6570 6595          uios.uio_iov = &iovs;
6571 6596          uios.uio_iovcnt = 1;
6572 6597          uios.uio_loffset = 0;
6573 6598          uios.uio_segflg = UIO_USERSPACE;
6574 6599          uios.uio_fmode = 0;
6575 6600          uios.uio_extflg = UIO_COPY_CACHED;
6576 6601          uios.uio_resid = mdata->maxlen;
6577 6602          uios.uio_offset = 0;
6578 6603  
6579 6604          q = _RD(stp->sd_wrq);
6580 6605          mutex_enter(&stp->sd_lock);
6581 6606          old_sd_flag = stp->sd_flag;
6582 6607          mark = 0;
6583 6608          for (;;) {
6584 6609                  int done = 0;
6585 6610                  mblk_t *q_first = q->q_first;
6586 6611  
6587 6612                  /*
6588 6613                   * Get the next message of appropriate priority
6589 6614                   * from the stream head.  If the caller is interested
6590 6615                   * in band or hipri messages, then they should already
6591 6616                   * be enqueued at the stream head.  On the other hand
6592 6617                   * if the caller wants normal (band 0) messages, they
6593 6618                   * might be deferred in a synchronous stream and they
6594 6619                   * will need to be pulled up.
6595 6620                   *
6596 6621                   * After we have dequeued a message, we might find that
6597 6622                   * it was a deferred M_SIG that was enqueued at the
6598 6623                   * stream head.  It must now be posted as part of the
6599 6624                   * read by calling strsignal_nolock().
6600 6625                   *
6601 6626                   * Also note that strrput does not enqueue an M_PCSIG,
6602 6627                   * and there cannot be more than one hipri message,
6603 6628                   * so there was no need to have the M_PCSIG case.
6604 6629                   *
6605 6630                   * At some time it might be nice to try and wrap the
6606 6631                   * functionality of kstrgetmsg() and strgetmsg() into
6607 6632                   * a common routine so to reduce the amount of replicated
6608 6633                   * code (since they are extremely similar).
6609 6634                   */
6610 6635                  if (!(*flagsp & (MSG_HIPRI|MSG_BAND))) {
6611 6636                          /* Asking for normal, band0 data */
6612 6637                          bp = strget(stp, q, uiop, first, &error);
6613 6638                          ASSERT(MUTEX_HELD(&stp->sd_lock));
6614 6639                          if (bp != NULL) {
6615 6640                                  if (DB_TYPE(bp) == M_SIG) {
6616 6641                                          strsignal_nolock(stp, *bp->b_rptr,
6617 6642                                              bp->b_band);
6618 6643                                          freemsg(bp);
6619 6644                                          continue;
6620 6645                                  } else {
6621 6646                                          break;
6622 6647                                  }
6623 6648                          }
6624 6649                          if (error != 0)
6625 6650                                  goto getmout;
6626 6651  
6627 6652                  /*
6628 6653                   * We can't depend on the value of STRPRI here because
6629 6654                   * the stream head may be in transit. Therefore, we
6630 6655                   * must look at the type of the first message to
6631 6656                   * determine if a high priority messages is waiting
6632 6657                   */
6633 6658                  } else if ((*flagsp & MSG_HIPRI) && q_first != NULL &&
6634 6659                      DB_TYPE(q_first) >= QPCTL &&
6635 6660                      (bp = getq_noenab(q, 0)) != NULL) {
6636 6661                          /* Asked for HIPRI and got one */
6637 6662                          ASSERT(DB_TYPE(bp) >= QPCTL);
6638 6663                          break;
6639 6664                  } else if ((*flagsp & MSG_BAND) && q_first != NULL &&
6640 6665                      ((q_first->b_band >= *prip) || DB_TYPE(q_first) >= QPCTL) &&
6641 6666                      (bp = getq_noenab(q, 0)) != NULL) {
6642 6667                          /*
6643 6668                           * Asked for at least band "prip" and got either at
6644 6669                           * least that band or a hipri message.
6645 6670                           */
6646 6671                          ASSERT(bp->b_band >= *prip || DB_TYPE(bp) >= QPCTL);
6647 6672                          if (DB_TYPE(bp) == M_SIG) {
6648 6673                                  strsignal_nolock(stp, *bp->b_rptr, bp->b_band);
6649 6674                                  freemsg(bp);
6650 6675                                  continue;
6651 6676                          } else {
6652 6677                                  break;
6653 6678                          }
6654 6679                  }
6655 6680  
6656 6681                  /* No data. Time to sleep? */
6657 6682                  qbackenable(q, 0);
6658 6683  
6659 6684                  /*
6660 6685                   * If STRHUP or STREOF, return 0 length control and data.
6661 6686                   * If resid is 0, then a read(fd,buf,0) was done. Do not
6662 6687                   * sleep to satisfy this request because by default we have
6663 6688                   * zero bytes to return.
6664 6689                   */
6665 6690                  if ((stp->sd_flag & (STRHUP|STREOF)) || (mctl->maxlen == 0 &&
6666 6691                      mdata->maxlen == 0)) {
6667 6692                          mctl->len = mdata->len = 0;
6668 6693                          *flagsp = 0;
6669 6694                          mutex_exit(&stp->sd_lock);
6670 6695                          return (0);
6671 6696                  }
6672 6697                  TRACE_2(TR_FAC_STREAMS_FR, TR_STRGETMSG_WAIT,
6673 6698                      "strgetmsg calls strwaitq:%p, %p",
6674 6699                      vp, uiop);
6675 6700                  if (((error = strwaitq(stp, GETWAIT, (ssize_t)0, fmode, -1,
6676 6701                      &done)) != 0) || done) {
6677 6702                          TRACE_2(TR_FAC_STREAMS_FR, TR_STRGETMSG_DONE,
6678 6703                              "strgetmsg error or done:%p, %p",
6679 6704                              vp, uiop);
6680 6705                          mutex_exit(&stp->sd_lock);
6681 6706                          return (error);
6682 6707                  }
6683 6708                  TRACE_2(TR_FAC_STREAMS_FR, TR_STRGETMSG_AWAKE,
6684 6709                      "strgetmsg awakes:%p, %p", vp, uiop);
6685 6710                  if ((error = i_straccess(stp, JCREAD)) != 0) {
6686 6711                          mutex_exit(&stp->sd_lock);
6687 6712                          return (error);
6688 6713                  }
6689 6714                  first = 0;
6690 6715          }
6691 6716          ASSERT(bp != NULL);
6692 6717          /*
6693 6718           * Extract any mark information. If the message is not completely
6694 6719           * consumed this information will be put in the mblk
6695 6720           * that is putback.
6696 6721           * If MSGMARKNEXT is set and the message is completely consumed
6697 6722           * the STRATMARK flag will be set below. Likewise, if
6698 6723           * MSGNOTMARKNEXT is set and the message is
6699 6724           * completely consumed STRNOTATMARK will be set.
6700 6725           */
6701 6726          mark = bp->b_flag & (MSGMARK | MSGMARKNEXT | MSGNOTMARKNEXT);
6702 6727          ASSERT((mark & (MSGMARKNEXT|MSGNOTMARKNEXT)) !=
6703 6728              (MSGMARKNEXT|MSGNOTMARKNEXT));
6704 6729          if (mark != 0 && bp == stp->sd_mark) {
6705 6730                  mark |= _LASTMARK;
6706 6731                  stp->sd_mark = NULL;
6707 6732          }
6708 6733          /*
6709 6734           * keep track of the original message type and priority
6710 6735           */
6711 6736          pri = bp->b_band;
6712 6737          type = bp->b_datap->db_type;
6713 6738          if (type == M_PASSFP) {
6714 6739                  if ((mark & _LASTMARK) && (stp->sd_mark == NULL))
6715 6740                          stp->sd_mark = bp;
6716 6741                  bp->b_flag |= mark & ~_LASTMARK;
6717 6742                  putback(stp, q, bp, pri);
6718 6743                  qbackenable(q, pri);
6719 6744                  mutex_exit(&stp->sd_lock);
6720 6745                  return (EBADMSG);
6721 6746          }
6722 6747          ASSERT(type != M_SIG);
6723 6748  
6724 6749          /*
6725 6750           * Set this flag so strrput will not generate signals. Need to
6726 6751           * make sure this flag is cleared before leaving this routine
6727 6752           * else signals will stop being sent.
6728 6753           */
6729 6754          stp->sd_flag |= STRGETINPROG;
6730 6755          mutex_exit(&stp->sd_lock);
6731 6756  
6732 6757          if (STREAM_NEEDSERVICE(stp))
6733 6758                  stream_runservice(stp);
6734 6759  
6735 6760          /*
6736 6761           * Set HIPRI flag if message is priority.
6737 6762           */
6738 6763          if (type >= QPCTL)
6739 6764                  flg = MSG_HIPRI;
6740 6765          else
6741 6766                  flg = MSG_BAND;
6742 6767  
6743 6768          /*
6744 6769           * First process PROTO or PCPROTO blocks, if any.
6745 6770           */
6746 6771          if (mctl->maxlen >= 0 && type != M_DATA) {
6747 6772                  size_t  n, bcnt;
6748 6773                  char    *ubuf;
6749 6774  
6750 6775                  bcnt = mctl->maxlen;
6751 6776                  ubuf = mctl->buf;
6752 6777                  while (bp != NULL && bp->b_datap->db_type != M_DATA) {
6753 6778                          if ((n = MIN(bcnt, bp->b_wptr - bp->b_rptr)) != 0 &&
6754 6779                              copyout(bp->b_rptr, ubuf, n)) {
6755 6780                                  error = EFAULT;
6756 6781                                  mutex_enter(&stp->sd_lock);
6757 6782                                  /*
6758 6783                                   * clear stream head pri flag based on
6759 6784                                   * first message type
6760 6785                                   */
6761 6786                                  if (type >= QPCTL) {
6762 6787                                          ASSERT(type == M_PCPROTO);
6763 6788                                          stp->sd_flag &= ~STRPRI;
6764 6789                                  }
6765 6790                                  more = 0;
6766 6791                                  freemsg(bp);
6767 6792                                  goto getmout;
6768 6793                          }
6769 6794                          ubuf += n;
6770 6795                          bp->b_rptr += n;
6771 6796                          if (bp->b_rptr >= bp->b_wptr) {
6772 6797                                  nbp = bp;
6773 6798                                  bp = bp->b_cont;
6774 6799                                  freeb(nbp);
6775 6800                          }
6776 6801                          ASSERT(n <= bcnt);
6777 6802                          bcnt -= n;
6778 6803                          if (bcnt == 0)
6779 6804                                  break;
6780 6805                  }
6781 6806                  mctl->len = mctl->maxlen - bcnt;
6782 6807          } else
6783 6808                  mctl->len = -1;
6784 6809  
6785 6810          if (bp && bp->b_datap->db_type != M_DATA) {
6786 6811                  /*
6787 6812                   * More PROTO blocks in msg.
6788 6813                   */
6789 6814                  more |= MORECTL;
6790 6815                  savemp = bp;
6791 6816                  while (bp && bp->b_datap->db_type != M_DATA) {
6792 6817                          savemptail = bp;
6793 6818                          bp = bp->b_cont;
6794 6819                  }
6795 6820                  savemptail->b_cont = NULL;
6796 6821          }
6797 6822  
6798 6823          /*
6799 6824           * Now process DATA blocks, if any.
6800 6825           */
6801 6826          if (mdata->maxlen >= 0 && bp) {
6802 6827                  /*
6803 6828                   * struiocopyout will consume a potential zero-length
6804 6829                   * M_DATA even if uio_resid is zero.
6805 6830                   */
6806 6831                  size_t oldresid = uiop->uio_resid;
6807 6832  
6808 6833                  bp = struiocopyout(bp, uiop, &error);
6809 6834                  if (error != 0) {
6810 6835                          mutex_enter(&stp->sd_lock);
6811 6836                          /*
6812 6837                           * clear stream head hi pri flag based on
6813 6838                           * first message
6814 6839                           */
6815 6840                          if (type >= QPCTL) {
6816 6841                                  ASSERT(type == M_PCPROTO);
6817 6842                                  stp->sd_flag &= ~STRPRI;
6818 6843                          }
6819 6844                          more = 0;
6820 6845                          freemsg(savemp);
6821 6846                          goto getmout;
6822 6847                  }
6823 6848                  /*
6824 6849                   * (pr == 1) indicates a partial read.
6825 6850                   */
6826 6851                  if (oldresid > uiop->uio_resid)
6827 6852                          pr = 1;
6828 6853                  mdata->len = mdata->maxlen - uiop->uio_resid;
6829 6854          } else
6830 6855                  mdata->len = -1;
6831 6856  
6832 6857          if (bp) {                       /* more data blocks in msg */
6833 6858                  more |= MOREDATA;
6834 6859                  if (savemp)
6835 6860                          savemptail->b_cont = bp;
6836 6861                  else
6837 6862                          savemp = bp;
6838 6863          }
6839 6864  
6840 6865          mutex_enter(&stp->sd_lock);
6841 6866          if (savemp) {
6842 6867                  if (pr && (savemp->b_datap->db_type == M_DATA) &&
6843 6868                      msgnodata(savemp)) {
6844 6869                          /*
6845 6870                           * Avoid queuing a zero-length tail part of
6846 6871                           * a message. pr=1 indicates that we read some of
6847 6872                           * the message.
6848 6873                           */
6849 6874                          freemsg(savemp);
6850 6875                          more &= ~MOREDATA;
6851 6876                          /*
6852 6877                           * clear stream head hi pri flag based on
6853 6878                           * first message
6854 6879                           */
6855 6880                          if (type >= QPCTL) {
6856 6881                                  ASSERT(type == M_PCPROTO);
6857 6882                                  stp->sd_flag &= ~STRPRI;
6858 6883                          }
6859 6884                  } else {
6860 6885                          savemp->b_band = pri;
6861 6886                          /*
6862 6887                           * If the first message was HIPRI and the one we're
6863 6888                           * putting back isn't, then clear STRPRI, otherwise
6864 6889                           * set STRPRI again.  Note that we must set STRPRI
6865 6890                           * again since the flush logic in strrput_nondata()
6866 6891                           * may have cleared it while we had sd_lock dropped.
6867 6892                           */
6868 6893                          if (type >= QPCTL) {
6869 6894                                  ASSERT(type == M_PCPROTO);
6870 6895                                  if (queclass(savemp) < QPCTL)
6871 6896                                          stp->sd_flag &= ~STRPRI;
6872 6897                                  else
6873 6898                                          stp->sd_flag |= STRPRI;
6874 6899                          } else if (queclass(savemp) >= QPCTL) {
6875 6900                                  /*
6876 6901                                   * The first message was not a HIPRI message,
6877 6902                                   * but the one we are about to putback is.
6878 6903                                   * For simplicitly, we do not allow for HIPRI
6879 6904                                   * messages to be embedded in the message
6880 6905                                   * body, so just force it to same type as
6881 6906                                   * first message.
6882 6907                                   */
6883 6908                                  ASSERT(type == M_DATA || type == M_PROTO);
6884 6909                                  ASSERT(savemp->b_datap->db_type == M_PCPROTO);
6885 6910                                  savemp->b_datap->db_type = type;
6886 6911                          }
6887 6912                          if (mark != 0) {
6888 6913                                  savemp->b_flag |= mark & ~_LASTMARK;
6889 6914                                  if ((mark & _LASTMARK) &&
6890 6915                                      (stp->sd_mark == NULL)) {
6891 6916                                          /*
6892 6917                                           * If another marked message arrived
6893 6918                                           * while sd_lock was not held sd_mark
6894 6919                                           * would be non-NULL.
6895 6920                                           */
6896 6921                                          stp->sd_mark = savemp;
6897 6922                                  }
6898 6923                          }
6899 6924                          putback(stp, q, savemp, pri);
6900 6925                  }
6901 6926          } else {
6902 6927                  /*
6903 6928                   * The complete message was consumed.
6904 6929                   *
6905 6930                   * If another M_PCPROTO arrived while sd_lock was not held
6906 6931                   * it would have been discarded since STRPRI was still set.
6907 6932                   *
6908 6933                   * Move the MSG*MARKNEXT information
6909 6934                   * to the stream head just in case
6910 6935                   * the read queue becomes empty.
6911 6936                   * clear stream head hi pri flag based on
6912 6937                   * first message
6913 6938                   *
6914 6939                   * If the stream head was at the mark
6915 6940                   * (STRATMARK) before we dropped sd_lock above
6916 6941                   * and some data was consumed then we have
6917 6942                   * moved past the mark thus STRATMARK is
6918 6943                   * cleared. However, if a message arrived in
6919 6944                   * strrput during the copyout above causing
6920 6945                   * STRATMARK to be set we can not clear that
6921 6946                   * flag.
6922 6947                   */
6923 6948                  if (type >= QPCTL) {
6924 6949                          ASSERT(type == M_PCPROTO);
6925 6950                          stp->sd_flag &= ~STRPRI;
6926 6951                  }
6927 6952                  if (mark & (MSGMARKNEXT|MSGNOTMARKNEXT|MSGMARK)) {
6928 6953                          if (mark & MSGMARKNEXT) {
6929 6954                                  stp->sd_flag &= ~STRNOTATMARK;
6930 6955                                  stp->sd_flag |= STRATMARK;
6931 6956                          } else if (mark & MSGNOTMARKNEXT) {
6932 6957                                  stp->sd_flag &= ~STRATMARK;
6933 6958                                  stp->sd_flag |= STRNOTATMARK;
6934 6959                          } else {
6935 6960                                  stp->sd_flag &= ~(STRATMARK|STRNOTATMARK);
6936 6961                          }
6937 6962                  } else if (pr && (old_sd_flag & STRATMARK)) {
6938 6963                          stp->sd_flag &= ~STRATMARK;
6939 6964                  }
6940 6965          }
6941 6966  
6942 6967          *flagsp = flg;
6943 6968          *prip = pri;
6944 6969  
6945 6970          /*
6946 6971           * Getmsg cleanup processing - if the state of the queue has changed
6947 6972           * some signals may need to be sent and/or poll awakened.
6948 6973           */
6949 6974  getmout:
6950 6975          qbackenable(q, pri);
6951 6976  
6952 6977          /*
6953 6978           * We dropped the stream head lock above. Send all M_SIG messages
6954 6979           * before processing stream head for SIGPOLL messages.
6955 6980           */
6956 6981          ASSERT(MUTEX_HELD(&stp->sd_lock));
6957 6982          while ((bp = q->q_first) != NULL &&
6958 6983              (bp->b_datap->db_type == M_SIG)) {
6959 6984                  /*
6960 6985                   * sd_lock is held so the content of the read queue can not
6961 6986                   * change.
6962 6987                   */
6963 6988                  bp = getq(q);
6964 6989                  ASSERT(bp != NULL && bp->b_datap->db_type == M_SIG);
6965 6990  
6966 6991                  strsignal_nolock(stp, *bp->b_rptr, bp->b_band);
6967 6992                  mutex_exit(&stp->sd_lock);
6968 6993                  freemsg(bp);
6969 6994                  if (STREAM_NEEDSERVICE(stp))
6970 6995                          stream_runservice(stp);
6971 6996                  mutex_enter(&stp->sd_lock);
6972 6997          }
6973 6998  
6974 6999          /*
6975 7000           * stream head cannot change while we make the determination
6976 7001           * whether or not to send a signal. Drop the flag to allow strrput
6977 7002           * to send firstmsgsigs again.
6978 7003           */
6979 7004          stp->sd_flag &= ~STRGETINPROG;
6980 7005  
6981 7006          /*
6982 7007           * If the type of message at the front of the queue changed
6983 7008           * due to the receive the appropriate signals and pollwakeup events
6984 7009           * are generated. The type of changes are:
6985 7010           *      Processed a hipri message, q_first is not hipri.
6986 7011           *      Processed a band X message, and q_first is band Y.
6987 7012           * The generated signals and pollwakeups are identical to what
6988 7013           * strrput() generates should the message that is now on q_first
6989 7014           * arrive to an empty read queue.
6990 7015           *
6991 7016           * Note: only strrput will send a signal for a hipri message.
6992 7017           */
6993 7018          if ((bp = q->q_first) != NULL && !(stp->sd_flag & STRPRI)) {
6994 7019                  strsigset_t signals = 0;
6995 7020                  strpollset_t pollwakeups = 0;
6996 7021  
6997 7022                  if (flg & MSG_HIPRI) {
6998 7023                          /*
6999 7024                           * Removed a hipri message. Regular data at
7000 7025                           * the front of  the queue.
7001 7026                           */
7002 7027                          if (bp->b_band == 0) {
7003 7028                                  signals = S_INPUT | S_RDNORM;
7004 7029                                  pollwakeups = POLLIN | POLLRDNORM;
7005 7030                          } else {
7006 7031                                  signals = S_INPUT | S_RDBAND;
7007 7032                                  pollwakeups = POLLIN | POLLRDBAND;
7008 7033                          }
7009 7034                  } else if (pri != bp->b_band) {
7010 7035                          /*
7011 7036                           * The band is different for the new q_first.
7012 7037                           */
7013 7038                          if (bp->b_band == 0) {
7014 7039                                  signals = S_RDNORM;
7015 7040                                  pollwakeups = POLLIN | POLLRDNORM;
7016 7041                          } else {
7017 7042                                  signals = S_RDBAND;
7018 7043                                  pollwakeups = POLLIN | POLLRDBAND;
7019 7044                          }
7020 7045                  }
7021 7046  
7022 7047                  if (pollwakeups != 0) {
7023 7048                          if (pollwakeups == (POLLIN | POLLRDNORM)) {
7024 7049                                  if (!(stp->sd_rput_opt & SR_POLLIN))
7025 7050                                          goto no_pollwake;
7026 7051                                  stp->sd_rput_opt &= ~SR_POLLIN;
7027 7052                          }
7028 7053                          mutex_exit(&stp->sd_lock);
7029 7054                          pollwakeup(&stp->sd_pollist, pollwakeups);
7030 7055                          mutex_enter(&stp->sd_lock);
7031 7056                  }
7032 7057  no_pollwake:
7033 7058  
7034 7059                  if (stp->sd_sigflags & signals)
7035 7060                          strsendsig(stp->sd_siglist, signals, bp->b_band, 0);
7036 7061          }
7037 7062          mutex_exit(&stp->sd_lock);
7038 7063  
7039 7064          rvp->r_val1 = more;
7040 7065          return (error);
7041 7066  #undef  _LASTMARK
7042 7067  }
7043 7068  
7044 7069  /*
7045 7070   * Get the next message from the read queue.  If the message is
7046 7071   * priority, STRPRI will have been set by strrput().  This flag
7047 7072   * should be reset only when the entire message at the front of the
7048 7073   * queue as been consumed.
7049 7074   *
7050 7075   * If uiop is NULL all data is returned in mctlp.
7051 7076   * Note that a NULL uiop implies that FNDELAY and FNONBLOCK are assumed
7052 7077   * not enabled.
7053 7078   * The timeout parameter is in milliseconds; -1 for infinity.
7054 7079   * This routine handles the consolidation private flags:
7055 7080   *      MSG_IGNERROR    Ignore any stream head error except STPLEX.
7056 7081   *      MSG_DELAYERROR  Defer the error check until the queue is empty.
7057 7082   *      MSG_HOLDSIG     Hold signals while waiting for data.
7058 7083   *      MSG_IPEEK       Only peek at messages.
7059 7084   *      MSG_DISCARDTAIL Discard the tail M_DATA part of the message
7060 7085   *                      that doesn't fit.
7061 7086   *      MSG_NOMARK      If the message is marked leave it on the queue.
7062 7087   *
7063 7088   * NOTE: strgetmsg and kstrgetmsg have much of the logic in common.
7064 7089   */
7065 7090  int
7066 7091  kstrgetmsg(
7067 7092          struct vnode *vp,
7068 7093          mblk_t **mctlp,
7069 7094          struct uio *uiop,
7070 7095          unsigned char *prip,
7071 7096          int *flagsp,
7072 7097          clock_t timout,
7073 7098          rval_t *rvp)
7074 7099  {
7075 7100          struct stdata *stp;
7076 7101          mblk_t *bp, *nbp;
7077 7102          mblk_t *savemp = NULL;
7078 7103          mblk_t *savemptail = NULL;
7079 7104          int flags;
7080 7105          uint_t old_sd_flag;
7081 7106          int flg;
7082 7107          int more = 0;
7083 7108          int error = 0;
7084 7109          char first = 1;
7085 7110          uint_t mark;            /* Contains MSG*MARK and _LASTMARK */
7086 7111  #define _LASTMARK       0x8000  /* Distinct from MSG*MARK */
7087 7112          unsigned char pri = 0;
7088 7113          queue_t *q;
7089 7114          int     pr = 0;                 /* Partial read successful */
7090 7115          unsigned char type;
7091 7116  
7092 7117          TRACE_1(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_ENTER,
7093 7118              "kstrgetmsg:%p", vp);
7094 7119  
7095 7120          ASSERT(vp->v_stream);
7096 7121          stp = vp->v_stream;
7097 7122          rvp->r_val1 = 0;
7098 7123  
7099 7124          mutex_enter(&stp->sd_lock);
7100 7125  
7101 7126          if ((error = i_straccess(stp, JCREAD)) != 0) {
7102 7127                  mutex_exit(&stp->sd_lock);
7103 7128                  return (error);
7104 7129          }
7105 7130  
7106 7131          flags = *flagsp;
7107 7132          if (stp->sd_flag & (STRDERR|STPLEX)) {
7108 7133                  if ((stp->sd_flag & STPLEX) ||
7109 7134                      (flags & (MSG_IGNERROR|MSG_DELAYERROR)) == 0) {
7110 7135                          error = strgeterr(stp, STRDERR|STPLEX,
7111 7136                              (flags & MSG_IPEEK));
7112 7137                          if (error != 0) {
7113 7138                                  mutex_exit(&stp->sd_lock);
7114 7139                                  return (error);
7115 7140                          }
7116 7141                  }
7117 7142          }
7118 7143          mutex_exit(&stp->sd_lock);
7119 7144  
7120 7145          switch (flags & (MSG_HIPRI|MSG_ANY|MSG_BAND)) {
7121 7146          case MSG_HIPRI:
7122 7147                  if (*prip != 0)
7123 7148                          return (EINVAL);
7124 7149                  break;
7125 7150  
7126 7151          case MSG_ANY:
7127 7152          case MSG_BAND:
7128 7153                  break;
7129 7154  
7130 7155          default:
7131 7156                  return (EINVAL);
7132 7157          }
7133 7158  
7134 7159  retry:
7135 7160          q = _RD(stp->sd_wrq);
7136 7161          mutex_enter(&stp->sd_lock);
7137 7162          old_sd_flag = stp->sd_flag;
7138 7163          mark = 0;
7139 7164          for (;;) {
7140 7165                  int done = 0;
7141 7166                  int waitflag;
7142 7167                  int fmode;
7143 7168                  mblk_t *q_first = q->q_first;
7144 7169  
7145 7170                  /*
7146 7171                   * This section of the code operates just like the code
7147 7172                   * in strgetmsg().  There is a comment there about what
7148 7173                   * is going on here.
7149 7174                   */
7150 7175                  if (!(flags & (MSG_HIPRI|MSG_BAND))) {
7151 7176                          /* Asking for normal, band0 data */
7152 7177                          bp = strget(stp, q, uiop, first, &error);
7153 7178                          ASSERT(MUTEX_HELD(&stp->sd_lock));
7154 7179                          if (bp != NULL) {
7155 7180                                  if (DB_TYPE(bp) == M_SIG) {
7156 7181                                          strsignal_nolock(stp, *bp->b_rptr,
7157 7182                                              bp->b_band);
7158 7183                                          freemsg(bp);
7159 7184                                          continue;
7160 7185                                  } else {
7161 7186                                          break;
7162 7187                                  }
7163 7188                          }
7164 7189                          if (error != 0) {
7165 7190                                  goto getmout;
7166 7191                          }
7167 7192                  /*
7168 7193                   * We can't depend on the value of STRPRI here because
7169 7194                   * the stream head may be in transit. Therefore, we
7170 7195                   * must look at the type of the first message to
7171 7196                   * determine if a high priority messages is waiting
7172 7197                   */
7173 7198                  } else if ((flags & MSG_HIPRI) && q_first != NULL &&
7174 7199                      DB_TYPE(q_first) >= QPCTL &&
7175 7200                      (bp = getq_noenab(q, 0)) != NULL) {
7176 7201                          ASSERT(DB_TYPE(bp) >= QPCTL);
7177 7202                          break;
7178 7203                  } else if ((flags & MSG_BAND) && q_first != NULL &&
7179 7204                      ((q_first->b_band >= *prip) || DB_TYPE(q_first) >= QPCTL) &&
7180 7205                      (bp = getq_noenab(q, 0)) != NULL) {
7181 7206                          /*
7182 7207                           * Asked for at least band "prip" and got either at
7183 7208                           * least that band or a hipri message.
7184 7209                           */
7185 7210                          ASSERT(bp->b_band >= *prip || DB_TYPE(bp) >= QPCTL);
7186 7211                          if (DB_TYPE(bp) == M_SIG) {
7187 7212                                  strsignal_nolock(stp, *bp->b_rptr, bp->b_band);
7188 7213                                  freemsg(bp);
7189 7214                                  continue;
7190 7215                          } else {
7191 7216                                  break;
7192 7217                          }
7193 7218                  }
7194 7219  
7195 7220                  /* No data. Time to sleep? */
7196 7221                  qbackenable(q, 0);
7197 7222  
7198 7223                  /*
7199 7224                   * Delayed error notification?
7200 7225                   */
7201 7226                  if ((stp->sd_flag & (STRDERR|STPLEX)) &&
7202 7227                      (flags & (MSG_IGNERROR|MSG_DELAYERROR)) == MSG_DELAYERROR) {
7203 7228                          error = strgeterr(stp, STRDERR|STPLEX,
7204 7229                              (flags & MSG_IPEEK));
7205 7230                          if (error != 0) {
7206 7231                                  mutex_exit(&stp->sd_lock);
7207 7232                                  return (error);
7208 7233                          }
7209 7234                  }
7210 7235  
7211 7236                  /*
7212 7237                   * If STRHUP or STREOF, return 0 length control and data.
7213 7238                   * If a read(fd,buf,0) has been done, do not sleep, just
7214 7239                   * return.
7215 7240                   *
7216 7241                   * If mctlp == NULL and uiop == NULL, then the code will
7217 7242                   * do the strwaitq. This is an understood way of saying
7218 7243                   * sleep "polling" until a message is received.
7219 7244                   */
7220 7245                  if ((stp->sd_flag & (STRHUP|STREOF)) ||
7221 7246                      (uiop != NULL && uiop->uio_resid == 0)) {
7222 7247                          if (mctlp != NULL)
7223 7248                                  *mctlp = NULL;
7224 7249                          *flagsp = 0;
7225 7250                          mutex_exit(&stp->sd_lock);
7226 7251                          return (0);
7227 7252                  }
7228 7253  
7229 7254                  waitflag = GETWAIT;
7230 7255                  if (flags &
7231 7256                      (MSG_HOLDSIG|MSG_IGNERROR|MSG_IPEEK|MSG_DELAYERROR)) {
7232 7257                          if (flags & MSG_HOLDSIG)
7233 7258                                  waitflag |= STR_NOSIG;
7234 7259                          if (flags & MSG_IGNERROR)
7235 7260                                  waitflag |= STR_NOERROR;
7236 7261                          if (flags & MSG_IPEEK)
7237 7262                                  waitflag |= STR_PEEK;
7238 7263                          if (flags & MSG_DELAYERROR)
7239 7264                                  waitflag |= STR_DELAYERR;
7240 7265                  }
7241 7266                  if (uiop != NULL)
7242 7267                          fmode = uiop->uio_fmode;
7243 7268                  else
7244 7269                          fmode = 0;
7245 7270  
7246 7271                  TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_WAIT,
7247 7272                      "kstrgetmsg calls strwaitq:%p, %p",
7248 7273                      vp, uiop);
7249 7274                  if (((error = strwaitq(stp, waitflag, (ssize_t)0,
7250 7275                      fmode, timout, &done))) != 0 || done) {
7251 7276                          TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_DONE,
7252 7277                              "kstrgetmsg error or done:%p, %p",
7253 7278                              vp, uiop);
7254 7279                          mutex_exit(&stp->sd_lock);
7255 7280                          return (error);
7256 7281                  }
7257 7282                  TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_AWAKE,
7258 7283                      "kstrgetmsg awakes:%p, %p", vp, uiop);
7259 7284                  if ((error = i_straccess(stp, JCREAD)) != 0) {
7260 7285                          mutex_exit(&stp->sd_lock);
7261 7286                          return (error);
7262 7287                  }
7263 7288                  first = 0;
7264 7289          }
7265 7290          ASSERT(bp != NULL);
7266 7291          /*
7267 7292           * Extract any mark information. If the message is not completely
7268 7293           * consumed this information will be put in the mblk
7269 7294           * that is putback.
7270 7295           * If MSGMARKNEXT is set and the message is completely consumed
7271 7296           * the STRATMARK flag will be set below. Likewise, if
7272 7297           * MSGNOTMARKNEXT is set and the message is
7273 7298           * completely consumed STRNOTATMARK will be set.
7274 7299           */
7275 7300          mark = bp->b_flag & (MSGMARK | MSGMARKNEXT | MSGNOTMARKNEXT);
7276 7301          ASSERT((mark & (MSGMARKNEXT|MSGNOTMARKNEXT)) !=
7277 7302              (MSGMARKNEXT|MSGNOTMARKNEXT));
7278 7303          pri = bp->b_band;
7279 7304          if (mark != 0) {
7280 7305                  /*
7281 7306                   * If the caller doesn't want the mark return.
7282 7307                   * Used to implement MSG_WAITALL in sockets.
7283 7308                   */
7284 7309                  if (flags & MSG_NOMARK) {
7285 7310                          putback(stp, q, bp, pri);
7286 7311                          qbackenable(q, pri);
7287 7312                          mutex_exit(&stp->sd_lock);
7288 7313                          return (EWOULDBLOCK);
7289 7314                  }
7290 7315                  if (bp == stp->sd_mark) {
7291 7316                          mark |= _LASTMARK;
7292 7317                          stp->sd_mark = NULL;
7293 7318                  }
7294 7319          }
7295 7320  
7296 7321          /*
7297 7322           * keep track of the first message type
7298 7323           */
7299 7324          type = bp->b_datap->db_type;
7300 7325  
7301 7326          if (bp->b_datap->db_type == M_PASSFP) {
7302 7327                  if ((mark & _LASTMARK) && (stp->sd_mark == NULL))
7303 7328                          stp->sd_mark = bp;
7304 7329                  bp->b_flag |= mark & ~_LASTMARK;
7305 7330                  putback(stp, q, bp, pri);
7306 7331                  qbackenable(q, pri);
7307 7332                  mutex_exit(&stp->sd_lock);
7308 7333                  return (EBADMSG);
7309 7334          }
7310 7335          ASSERT(type != M_SIG);
7311 7336  
7312 7337          if (flags & MSG_IPEEK) {
7313 7338                  /*
7314 7339                   * Clear any struioflag - we do the uiomove over again
7315 7340                   * when peeking since it simplifies the code.
7316 7341                   *
7317 7342                   * Dup the message and put the original back on the queue.
7318 7343                   * If dupmsg() fails, try again with copymsg() to see if
7319 7344                   * there is indeed a shortage of memory.  dupmsg() may fail
7320 7345                   * if db_ref in any of the messages reaches its limit.
7321 7346                   */
7322 7347  
7323 7348                  if ((nbp = dupmsg(bp)) == NULL && (nbp = copymsg(bp)) == NULL) {
7324 7349                          /*
7325 7350                           * Restore the state of the stream head since we
7326 7351                           * need to drop sd_lock (strwaitbuf is sleeping).
7327 7352                           */
7328 7353                          size_t size = msgdsize(bp);
7329 7354  
7330 7355                          if ((mark & _LASTMARK) && (stp->sd_mark == NULL))
7331 7356                                  stp->sd_mark = bp;
7332 7357                          bp->b_flag |= mark & ~_LASTMARK;
7333 7358                          putback(stp, q, bp, pri);
7334 7359                          mutex_exit(&stp->sd_lock);
7335 7360                          error = strwaitbuf(size, BPRI_HI);
7336 7361                          if (error) {
7337 7362                                  /*
7338 7363                                   * There is no net change to the queue thus
7339 7364                                   * no need to qbackenable.
7340 7365                                   */
7341 7366                                  return (error);
7342 7367                          }
7343 7368                          goto retry;
7344 7369                  }
7345 7370  
7346 7371                  if ((mark & _LASTMARK) && (stp->sd_mark == NULL))
7347 7372                          stp->sd_mark = bp;
7348 7373                  bp->b_flag |= mark & ~_LASTMARK;
7349 7374                  putback(stp, q, bp, pri);
7350 7375                  bp = nbp;
7351 7376          }
7352 7377  
7353 7378          /*
7354 7379           * Set this flag so strrput will not generate signals. Need to
7355 7380           * make sure this flag is cleared before leaving this routine
7356 7381           * else signals will stop being sent.
7357 7382           */
7358 7383          stp->sd_flag |= STRGETINPROG;
7359 7384          mutex_exit(&stp->sd_lock);
7360 7385  
7361 7386          if ((stp->sd_rputdatafunc != NULL) && (DB_TYPE(bp) == M_DATA)) {
7362 7387                  mblk_t *tmp, *prevmp;
7363 7388  
7364 7389                  /*
7365 7390                   * Put first non-data mblk back to stream head and
7366 7391                   * cut the mblk chain so sd_rputdatafunc only sees
7367 7392                   * M_DATA mblks. We can skip the first mblk since it
7368 7393                   * is M_DATA according to the condition above.
7369 7394                   */
7370 7395                  for (prevmp = bp, tmp = bp->b_cont; tmp != NULL;
7371 7396                      prevmp = tmp, tmp = tmp->b_cont) {
7372 7397                          if (DB_TYPE(tmp) != M_DATA) {
7373 7398                                  prevmp->b_cont = NULL;
7374 7399                                  mutex_enter(&stp->sd_lock);
7375 7400                                  putback(stp, q, tmp, tmp->b_band);
7376 7401                                  mutex_exit(&stp->sd_lock);
7377 7402                                  break;
7378 7403                          }
7379 7404                  }
7380 7405  
7381 7406                  bp = (stp->sd_rputdatafunc)(stp->sd_vnode, bp,
7382 7407                      NULL, NULL, NULL, NULL);
7383 7408  
7384 7409                  if (bp == NULL)
7385 7410                          goto retry;
7386 7411          }
7387 7412  
7388 7413          if (STREAM_NEEDSERVICE(stp))
7389 7414                  stream_runservice(stp);
7390 7415  
7391 7416          /*
7392 7417           * Set HIPRI flag if message is priority.
7393 7418           */
7394 7419          if (type >= QPCTL)
7395 7420                  flg = MSG_HIPRI;
7396 7421          else
7397 7422                  flg = MSG_BAND;
7398 7423  
7399 7424          /*
7400 7425           * First process PROTO or PCPROTO blocks, if any.
7401 7426           */
7402 7427          if (mctlp != NULL && type != M_DATA) {
7403 7428                  mblk_t *nbp;
7404 7429  
7405 7430                  *mctlp = bp;
7406 7431                  while (bp->b_cont && bp->b_cont->b_datap->db_type != M_DATA)
7407 7432                          bp = bp->b_cont;
7408 7433                  nbp = bp->b_cont;
7409 7434                  bp->b_cont = NULL;
7410 7435                  bp = nbp;
7411 7436          }
7412 7437  
7413 7438          if (bp && bp->b_datap->db_type != M_DATA) {
7414 7439                  /*
7415 7440                   * More PROTO blocks in msg. Will only happen if mctlp is NULL.
7416 7441                   */
7417 7442                  more |= MORECTL;
7418 7443                  savemp = bp;
7419 7444                  while (bp && bp->b_datap->db_type != M_DATA) {
7420 7445                          savemptail = bp;
7421 7446                          bp = bp->b_cont;
7422 7447                  }
7423 7448                  savemptail->b_cont = NULL;
7424 7449          }
7425 7450  
7426 7451          /*
7427 7452           * Now process DATA blocks, if any.
7428 7453           */
7429 7454          if (uiop == NULL) {
7430 7455                  /* Append data to tail of mctlp */
7431 7456  
7432 7457                  if (mctlp != NULL) {
7433 7458                          mblk_t **mpp = mctlp;
7434 7459  
7435 7460                          while (*mpp != NULL)
7436 7461                                  mpp = &((*mpp)->b_cont);
7437 7462                          *mpp = bp;
7438 7463                          bp = NULL;
7439 7464                  }
7440 7465          } else if (uiop->uio_resid >= 0 && bp) {
7441 7466                  size_t oldresid = uiop->uio_resid;
7442 7467  
7443 7468                  /*
7444 7469                   * If a streams message is likely to consist
7445 7470                   * of many small mblks, it is pulled up into
7446 7471                   * one continuous chunk of memory.
7447 7472                   * The size of the first mblk may be bogus because
7448 7473                   * successive read() calls on the socket reduce
7449 7474                   * the size of this mblk until it is exhausted
7450 7475                   * and then the code walks on to the next. Thus
7451 7476                   * the size of the mblk may not be the original size
7452 7477                   * that was passed up, it's simply a remainder
7453 7478                   * and hence can be very small without any
7454 7479                   * implication that the packet is badly fragmented.
7455 7480                   * So the size of the possible second mblk is
7456 7481                   * used to spot a badly fragmented packet.
7457 7482                   * see longer comment at top of page
7458 7483                   * by mblk_pull_len declaration.
7459 7484                   */
7460 7485  
7461 7486                  if (bp->b_cont != NULL && MBLKL(bp->b_cont) < mblk_pull_len) {
7462 7487                          (void) pullupmsg(bp, -1);
7463 7488                  }
7464 7489  
7465 7490                  bp = struiocopyout(bp, uiop, &error);
7466 7491                  if (error != 0) {
7467 7492                          if (mctlp != NULL) {
7468 7493                                  freemsg(*mctlp);
7469 7494                                  *mctlp = NULL;
7470 7495                          } else
7471 7496                                  freemsg(savemp);
7472 7497                          mutex_enter(&stp->sd_lock);
7473 7498                          /*
7474 7499                           * clear stream head hi pri flag based on
7475 7500                           * first message
7476 7501                           */
7477 7502                          if (!(flags & MSG_IPEEK) && (type >= QPCTL)) {
7478 7503                                  ASSERT(type == M_PCPROTO);
7479 7504                                  stp->sd_flag &= ~STRPRI;
7480 7505                          }
7481 7506                          more = 0;
7482 7507                          goto getmout;
7483 7508                  }
7484 7509                  /*
7485 7510                   * (pr == 1) indicates a partial read.
7486 7511                   */
7487 7512                  if (oldresid > uiop->uio_resid)
7488 7513                          pr = 1;
7489 7514          }
7490 7515  
7491 7516          if (bp) {                       /* more data blocks in msg */
7492 7517                  more |= MOREDATA;
7493 7518                  if (savemp)
7494 7519                          savemptail->b_cont = bp;
7495 7520                  else
7496 7521                          savemp = bp;
7497 7522          }
7498 7523  
7499 7524          mutex_enter(&stp->sd_lock);
7500 7525          if (savemp) {
7501 7526                  if (flags & (MSG_IPEEK|MSG_DISCARDTAIL)) {
7502 7527                          /*
7503 7528                           * When MSG_DISCARDTAIL is set or
7504 7529                           * when peeking discard any tail. When peeking this
7505 7530                           * is the tail of the dup that was copied out - the
7506 7531                           * message has already been putback on the queue.
7507 7532                           * Return MOREDATA to the caller even though the data
7508 7533                           * is discarded. This is used by sockets (to
7509 7534                           * set MSG_TRUNC).
7510 7535                           */
7511 7536                          freemsg(savemp);
7512 7537                          if (!(flags & MSG_IPEEK) && (type >= QPCTL)) {
7513 7538                                  ASSERT(type == M_PCPROTO);
7514 7539                                  stp->sd_flag &= ~STRPRI;
7515 7540                          }
7516 7541                  } else if (pr && (savemp->b_datap->db_type == M_DATA) &&
7517 7542                      msgnodata(savemp)) {
7518 7543                          /*
7519 7544                           * Avoid queuing a zero-length tail part of
7520 7545                           * a message. pr=1 indicates that we read some of
7521 7546                           * the message.
7522 7547                           */
7523 7548                          freemsg(savemp);
7524 7549                          more &= ~MOREDATA;
7525 7550                          if (type >= QPCTL) {
7526 7551                                  ASSERT(type == M_PCPROTO);
7527 7552                                  stp->sd_flag &= ~STRPRI;
7528 7553                          }
7529 7554                  } else {
7530 7555                          savemp->b_band = pri;
7531 7556                          /*
7532 7557                           * If the first message was HIPRI and the one we're
7533 7558                           * putting back isn't, then clear STRPRI, otherwise
7534 7559                           * set STRPRI again.  Note that we must set STRPRI
7535 7560                           * again since the flush logic in strrput_nondata()
7536 7561                           * may have cleared it while we had sd_lock dropped.
7537 7562                           */
7538 7563  
7539 7564                          if (type >= QPCTL) {
7540 7565                                  ASSERT(type == M_PCPROTO);
7541 7566                                  if (queclass(savemp) < QPCTL)
7542 7567                                          stp->sd_flag &= ~STRPRI;
7543 7568                                  else
7544 7569                                          stp->sd_flag |= STRPRI;
7545 7570                          } else if (queclass(savemp) >= QPCTL) {
7546 7571                                  /*
7547 7572                                   * The first message was not a HIPRI message,
7548 7573                                   * but the one we are about to putback is.
7549 7574                                   * For simplicitly, we do not allow for HIPRI
7550 7575                                   * messages to be embedded in the message
7551 7576                                   * body, so just force it to same type as
7552 7577                                   * first message.
7553 7578                                   */
7554 7579                                  ASSERT(type == M_DATA || type == M_PROTO);
7555 7580                                  ASSERT(savemp->b_datap->db_type == M_PCPROTO);
7556 7581                                  savemp->b_datap->db_type = type;
7557 7582                          }
7558 7583                          if (mark != 0) {
7559 7584                                  if ((mark & _LASTMARK) &&
7560 7585                                      (stp->sd_mark == NULL)) {
7561 7586                                          /*
7562 7587                                           * If another marked message arrived
7563 7588                                           * while sd_lock was not held sd_mark
7564 7589                                           * would be non-NULL.
7565 7590                                           */
7566 7591                                          stp->sd_mark = savemp;
7567 7592                                  }
7568 7593                                  savemp->b_flag |= mark & ~_LASTMARK;
7569 7594                          }
7570 7595                          putback(stp, q, savemp, pri);
7571 7596                  }
7572 7597          } else if (!(flags & MSG_IPEEK)) {
7573 7598                  /*
7574 7599                   * The complete message was consumed.
7575 7600                   *
7576 7601                   * If another M_PCPROTO arrived while sd_lock was not held
7577 7602                   * it would have been discarded since STRPRI was still set.
7578 7603                   *
7579 7604                   * Move the MSG*MARKNEXT information
7580 7605                   * to the stream head just in case
7581 7606                   * the read queue becomes empty.
7582 7607                   * clear stream head hi pri flag based on
7583 7608                   * first message
7584 7609                   *
7585 7610                   * If the stream head was at the mark
7586 7611                   * (STRATMARK) before we dropped sd_lock above
7587 7612                   * and some data was consumed then we have
7588 7613                   * moved past the mark thus STRATMARK is
7589 7614                   * cleared. However, if a message arrived in
7590 7615                   * strrput during the copyout above causing
7591 7616                   * STRATMARK to be set we can not clear that
7592 7617                   * flag.
7593 7618                   * XXX A "perimeter" would help by single-threading strrput,
7594 7619                   * strread, strgetmsg and kstrgetmsg.
7595 7620                   */
7596 7621                  if (type >= QPCTL) {
7597 7622                          ASSERT(type == M_PCPROTO);
7598 7623                          stp->sd_flag &= ~STRPRI;
7599 7624                  }
7600 7625                  if (mark & (MSGMARKNEXT|MSGNOTMARKNEXT|MSGMARK)) {
7601 7626                          if (mark & MSGMARKNEXT) {
7602 7627                                  stp->sd_flag &= ~STRNOTATMARK;
7603 7628                                  stp->sd_flag |= STRATMARK;
7604 7629                          } else if (mark & MSGNOTMARKNEXT) {
7605 7630                                  stp->sd_flag &= ~STRATMARK;
7606 7631                                  stp->sd_flag |= STRNOTATMARK;
7607 7632                          } else {
7608 7633                                  stp->sd_flag &= ~(STRATMARK|STRNOTATMARK);
7609 7634                          }
7610 7635                  } else if (pr && (old_sd_flag & STRATMARK)) {
7611 7636                          stp->sd_flag &= ~STRATMARK;
7612 7637                  }
7613 7638          }
7614 7639  
7615 7640          *flagsp = flg;
7616 7641          *prip = pri;
7617 7642  
7618 7643          /*
7619 7644           * Getmsg cleanup processing - if the state of the queue has changed
7620 7645           * some signals may need to be sent and/or poll awakened.
7621 7646           */
7622 7647  getmout:
7623 7648          qbackenable(q, pri);
7624 7649  
7625 7650          /*
7626 7651           * We dropped the stream head lock above. Send all M_SIG messages
7627 7652           * before processing stream head for SIGPOLL messages.
7628 7653           */
7629 7654          ASSERT(MUTEX_HELD(&stp->sd_lock));
7630 7655          while ((bp = q->q_first) != NULL &&
7631 7656              (bp->b_datap->db_type == M_SIG)) {
7632 7657                  /*
7633 7658                   * sd_lock is held so the content of the read queue can not
7634 7659                   * change.
7635 7660                   */
7636 7661                  bp = getq(q);
7637 7662                  ASSERT(bp != NULL && bp->b_datap->db_type == M_SIG);
7638 7663  
7639 7664                  strsignal_nolock(stp, *bp->b_rptr, bp->b_band);
7640 7665                  mutex_exit(&stp->sd_lock);
7641 7666                  freemsg(bp);
7642 7667                  if (STREAM_NEEDSERVICE(stp))
7643 7668                          stream_runservice(stp);
7644 7669                  mutex_enter(&stp->sd_lock);
7645 7670          }
7646 7671  
7647 7672          /*
7648 7673           * stream head cannot change while we make the determination
7649 7674           * whether or not to send a signal. Drop the flag to allow strrput
7650 7675           * to send firstmsgsigs again.
7651 7676           */
7652 7677          stp->sd_flag &= ~STRGETINPROG;
7653 7678  
7654 7679          /*
7655 7680           * If the type of message at the front of the queue changed
7656 7681           * due to the receive the appropriate signals and pollwakeup events
7657 7682           * are generated. The type of changes are:
7658 7683           *      Processed a hipri message, q_first is not hipri.
7659 7684           *      Processed a band X message, and q_first is band Y.
7660 7685           * The generated signals and pollwakeups are identical to what
7661 7686           * strrput() generates should the message that is now on q_first
7662 7687           * arrive to an empty read queue.
7663 7688           *
7664 7689           * Note: only strrput will send a signal for a hipri message.
7665 7690           */
7666 7691          if ((bp = q->q_first) != NULL && !(stp->sd_flag & STRPRI)) {
7667 7692                  strsigset_t signals = 0;
7668 7693                  strpollset_t pollwakeups = 0;
7669 7694  
7670 7695                  if (flg & MSG_HIPRI) {
7671 7696                          /*
7672 7697                           * Removed a hipri message. Regular data at
7673 7698                           * the front of  the queue.
7674 7699                           */
7675 7700                          if (bp->b_band == 0) {
7676 7701                                  signals = S_INPUT | S_RDNORM;
7677 7702                                  pollwakeups = POLLIN | POLLRDNORM;
7678 7703                          } else {
7679 7704                                  signals = S_INPUT | S_RDBAND;
7680 7705                                  pollwakeups = POLLIN | POLLRDBAND;
7681 7706                          }
7682 7707                  } else if (pri != bp->b_band) {
7683 7708                          /*
7684 7709                           * The band is different for the new q_first.
7685 7710                           */
7686 7711                          if (bp->b_band == 0) {
7687 7712                                  signals = S_RDNORM;
7688 7713                                  pollwakeups = POLLIN | POLLRDNORM;
7689 7714                          } else {
7690 7715                                  signals = S_RDBAND;
7691 7716                                  pollwakeups = POLLIN | POLLRDBAND;
7692 7717                          }
7693 7718                  }
7694 7719  
7695 7720                  if (pollwakeups != 0) {
7696 7721                          if (pollwakeups == (POLLIN | POLLRDNORM)) {
7697 7722                                  if (!(stp->sd_rput_opt & SR_POLLIN))
7698 7723                                          goto no_pollwake;
7699 7724                                  stp->sd_rput_opt &= ~SR_POLLIN;
7700 7725                          }
7701 7726                          mutex_exit(&stp->sd_lock);
7702 7727                          pollwakeup(&stp->sd_pollist, pollwakeups);
7703 7728                          mutex_enter(&stp->sd_lock);
7704 7729                  }
7705 7730  no_pollwake:
7706 7731  
7707 7732                  if (stp->sd_sigflags & signals)
7708 7733                          strsendsig(stp->sd_siglist, signals, bp->b_band, 0);
7709 7734          }
7710 7735          mutex_exit(&stp->sd_lock);
7711 7736  
7712 7737          rvp->r_val1 = more;
7713 7738          return (error);
7714 7739  #undef  _LASTMARK
7715 7740  }
7716 7741  
7717 7742  /*
7718 7743   * Put a message downstream.
7719 7744   *
7720 7745   * NOTE: strputmsg and kstrputmsg have much of the logic in common.
7721 7746   */
7722 7747  int
7723 7748  strputmsg(
7724 7749          struct vnode *vp,
7725 7750          struct strbuf *mctl,
7726 7751          struct strbuf *mdata,
7727 7752          unsigned char pri,
7728 7753          int flag,
7729 7754          int fmode)
7730 7755  {
7731 7756          struct stdata *stp;
7732 7757          queue_t *wqp;
7733 7758          mblk_t *mp;
7734 7759          ssize_t msgsize;
7735 7760          ssize_t rmin, rmax;
7736 7761          int error;
7737 7762          struct uio uios;
7738 7763          struct uio *uiop = &uios;
7739 7764          struct iovec iovs;
7740 7765          int xpg4 = 0;
7741 7766  
7742 7767          ASSERT(vp->v_stream);
7743 7768          stp = vp->v_stream;
7744 7769          wqp = stp->sd_wrq;
7745 7770  
7746 7771          /*
7747 7772           * If it is an XPG4 application, we need to send
7748 7773           * SIGPIPE below
7749 7774           */
7750 7775  
7751 7776          xpg4 = (flag & MSG_XPG4) ? 1 : 0;
7752 7777          flag &= ~MSG_XPG4;
7753 7778  
7754 7779          if (AU_AUDITING())
7755 7780                  audit_strputmsg(vp, mctl, mdata, pri, flag, fmode);
7756 7781  
7757 7782          mutex_enter(&stp->sd_lock);
7758 7783  
7759 7784          if ((error = i_straccess(stp, JCWRITE)) != 0) {
7760 7785                  mutex_exit(&stp->sd_lock);
7761 7786                  return (error);
7762 7787          }
7763 7788  
7764 7789          if (stp->sd_flag & (STWRERR|STRHUP|STPLEX)) {
7765 7790                  error = strwriteable(stp, B_FALSE, xpg4);
7766 7791                  if (error != 0) {
7767 7792                          mutex_exit(&stp->sd_lock);
7768 7793                          return (error);
7769 7794                  }
7770 7795          }
7771 7796  
7772 7797          mutex_exit(&stp->sd_lock);
7773 7798  
7774 7799          /*
7775 7800           * Check for legal flag value.
7776 7801           */
7777 7802          switch (flag) {
7778 7803          case MSG_HIPRI:
7779 7804                  if ((mctl->len < 0) || (pri != 0))
7780 7805                          return (EINVAL);
7781 7806                  break;
7782 7807          case MSG_BAND:
7783 7808                  break;
7784 7809  
7785 7810          default:
7786 7811                  return (EINVAL);
7787 7812          }
7788 7813  
7789 7814          TRACE_1(TR_FAC_STREAMS_FR, TR_STRPUTMSG_IN,
7790 7815              "strputmsg in:stp %p", stp);
7791 7816  
7792 7817          /* get these values from those cached in the stream head */
7793 7818          rmin = stp->sd_qn_minpsz;
7794 7819          rmax = stp->sd_qn_maxpsz;
7795 7820  
7796 7821          /*
7797 7822           * Make sure ctl and data sizes together fall within the
7798 7823           * limits of the max and min receive packet sizes and do
7799 7824           * not exceed system limit.
7800 7825           */
7801 7826          ASSERT((rmax >= 0) || (rmax == INFPSZ));
7802 7827          if (rmax == 0) {
7803 7828                  return (ERANGE);
7804 7829          }
7805 7830          /*
7806 7831           * Use the MAXIMUM of sd_maxblk and q_maxpsz.
7807 7832           * Needed to prevent partial failures in the strmakedata loop.
7808 7833           */
7809 7834          if (stp->sd_maxblk != INFPSZ && rmax != INFPSZ && rmax < stp->sd_maxblk)
7810 7835                  rmax = stp->sd_maxblk;
7811 7836  
7812 7837          if ((msgsize = mdata->len) < 0) {
7813 7838                  msgsize = 0;
7814 7839                  rmin = 0;       /* no range check for NULL data part */
7815 7840          }
7816 7841          if ((msgsize < rmin) ||
7817 7842              ((msgsize > rmax) && (rmax != INFPSZ)) ||
7818 7843              (mctl->len > strctlsz)) {
7819 7844                  return (ERANGE);
7820 7845          }
7821 7846  
7822 7847          /*
7823 7848           * Setup uio and iov for data part
7824 7849           */
7825 7850          iovs.iov_base = mdata->buf;
7826 7851          iovs.iov_len = msgsize;
7827 7852          uios.uio_iov = &iovs;
7828 7853          uios.uio_iovcnt = 1;
7829 7854          uios.uio_loffset = 0;
7830 7855          uios.uio_segflg = UIO_USERSPACE;
7831 7856          uios.uio_fmode = fmode;
7832 7857          uios.uio_extflg = UIO_COPY_DEFAULT;
7833 7858          uios.uio_resid = msgsize;
7834 7859          uios.uio_offset = 0;
7835 7860  
7836 7861          /* Ignore flow control in strput for HIPRI */
7837 7862          if (flag & MSG_HIPRI)
7838 7863                  flag |= MSG_IGNFLOW;
7839 7864  
7840 7865          for (;;) {
7841 7866                  int done = 0;
7842 7867  
7843 7868                  /*
7844 7869                   * strput will always free the ctl mblk - even when strput
7845 7870                   * fails.
7846 7871                   */
7847 7872                  if ((error = strmakectl(mctl, flag, fmode, &mp)) != 0) {
7848 7873                          TRACE_3(TR_FAC_STREAMS_FR, TR_STRPUTMSG_OUT,
7849 7874                              "strputmsg out:stp %p out %d error %d",
7850 7875                              stp, 1, error);
7851 7876                          return (error);
7852 7877                  }
7853 7878                  /*
7854 7879                   * Verify that the whole message can be transferred by
7855 7880                   * strput.
7856 7881                   */
7857 7882                  ASSERT(stp->sd_maxblk == INFPSZ ||
7858 7883                      stp->sd_maxblk >= mdata->len);
7859 7884  
7860 7885                  msgsize = mdata->len;
7861 7886                  error = strput(stp, mp, uiop, &msgsize, 0, pri, flag);
7862 7887                  mdata->len = msgsize;
7863 7888  
7864 7889                  if (error == 0)
7865 7890                          break;
7866 7891  
7867 7892                  if (error != EWOULDBLOCK)
7868 7893                          goto out;
7869 7894  
7870 7895                  mutex_enter(&stp->sd_lock);
7871 7896                  /*
7872 7897                   * Check for a missed wakeup.
7873 7898                   * Needed since strput did not hold sd_lock across
7874 7899                   * the canputnext.
7875 7900                   */
7876 7901                  if (bcanputnext(wqp, pri)) {
7877 7902                          /* Try again */
7878 7903                          mutex_exit(&stp->sd_lock);
7879 7904                          continue;
7880 7905                  }
7881 7906                  TRACE_2(TR_FAC_STREAMS_FR, TR_STRPUTMSG_WAIT,
7882 7907                      "strputmsg wait:stp %p waits pri %d", stp, pri);
7883 7908                  if (((error = strwaitq(stp, WRITEWAIT, (ssize_t)0, fmode, -1,
7884 7909                      &done)) != 0) || done) {
7885 7910                          mutex_exit(&stp->sd_lock);
7886 7911                          TRACE_3(TR_FAC_STREAMS_FR, TR_STRPUTMSG_OUT,
7887 7912                              "strputmsg out:q %p out %d error %d",
7888 7913                              stp, 0, error);
7889 7914                          return (error);
7890 7915                  }
7891 7916                  TRACE_1(TR_FAC_STREAMS_FR, TR_STRPUTMSG_WAKE,
7892 7917                      "strputmsg wake:stp %p wakes", stp);
7893 7918                  if ((error = i_straccess(stp, JCWRITE)) != 0) {
7894 7919                          mutex_exit(&stp->sd_lock);
7895 7920                          return (error);
7896 7921                  }
7897 7922                  mutex_exit(&stp->sd_lock);
7898 7923          }
7899 7924  out:
7900 7925          /*
7901 7926           * For historic reasons, applications expect EAGAIN
7902 7927           * when data mblk could not be allocated. so change
7903 7928           * ENOMEM back to EAGAIN
7904 7929           */
7905 7930          if (error == ENOMEM)
7906 7931                  error = EAGAIN;
7907 7932          TRACE_3(TR_FAC_STREAMS_FR, TR_STRPUTMSG_OUT,
7908 7933              "strputmsg out:stp %p out %d error %d", stp, 2, error);
7909 7934          return (error);
7910 7935  }
7911 7936  
7912 7937  /*
7913 7938   * Put a message downstream.
7914 7939   * Can send only an M_PROTO/M_PCPROTO by passing in a NULL uiop.
7915 7940   * The fmode flag (NDELAY, NONBLOCK) is the or of the flags in the uio
7916 7941   * and the fmode parameter.
7917 7942   *
7918 7943   * This routine handles the consolidation private flags:
7919 7944   *      MSG_IGNERROR    Ignore any stream head error except STPLEX.
7920 7945   *      MSG_HOLDSIG     Hold signals while waiting for data.
7921 7946   *      MSG_IGNFLOW     Don't check streams flow control.
7922 7947   *
7923 7948   * NOTE: strputmsg and kstrputmsg have much of the logic in common.
7924 7949   */
7925 7950  int
7926 7951  kstrputmsg(
7927 7952          struct vnode *vp,
7928 7953          mblk_t *mctl,
7929 7954          struct uio *uiop,
7930 7955          ssize_t msgsize,
7931 7956          unsigned char pri,
7932 7957          int flag,
7933 7958          int fmode)
7934 7959  {
7935 7960          struct stdata *stp;
7936 7961          queue_t *wqp;
7937 7962          ssize_t rmin, rmax;
7938 7963          int error;
7939 7964  
7940 7965          ASSERT(vp->v_stream);
7941 7966          stp = vp->v_stream;
7942 7967          wqp = stp->sd_wrq;
7943 7968          if (AU_AUDITING())
7944 7969                  audit_strputmsg(vp, NULL, NULL, pri, flag, fmode);
7945 7970          if (mctl == NULL)
7946 7971                  return (EINVAL);
7947 7972  
7948 7973          mutex_enter(&stp->sd_lock);
7949 7974  
7950 7975          if ((error = i_straccess(stp, JCWRITE)) != 0) {
7951 7976                  mutex_exit(&stp->sd_lock);
7952 7977                  freemsg(mctl);
7953 7978                  return (error);
7954 7979          }
7955 7980  
7956 7981          if ((stp->sd_flag & STPLEX) || !(flag & MSG_IGNERROR)) {
7957 7982                  if (stp->sd_flag & (STWRERR|STRHUP|STPLEX)) {
7958 7983                          error = strwriteable(stp, B_FALSE, B_TRUE);
7959 7984                          if (error != 0) {
7960 7985                                  mutex_exit(&stp->sd_lock);
7961 7986                                  freemsg(mctl);
7962 7987                                  return (error);
7963 7988                          }
7964 7989                  }
7965 7990          }
7966 7991  
7967 7992          mutex_exit(&stp->sd_lock);
7968 7993  
7969 7994          /*
7970 7995           * Check for legal flag value.
7971 7996           */
7972 7997          switch (flag & (MSG_HIPRI|MSG_BAND|MSG_ANY)) {
7973 7998          case MSG_HIPRI:
7974 7999                  if (pri != 0) {
7975 8000                          freemsg(mctl);
7976 8001                          return (EINVAL);
7977 8002                  }
7978 8003                  break;
7979 8004          case MSG_BAND:
7980 8005                  break;
7981 8006          default:
7982 8007                  freemsg(mctl);
7983 8008                  return (EINVAL);
7984 8009          }
7985 8010  
7986 8011          TRACE_1(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_IN,
7987 8012              "kstrputmsg in:stp %p", stp);
7988 8013  
7989 8014          /* get these values from those cached in the stream head */
7990 8015          rmin = stp->sd_qn_minpsz;
7991 8016          rmax = stp->sd_qn_maxpsz;
7992 8017  
7993 8018          /*
7994 8019           * Make sure ctl and data sizes together fall within the
7995 8020           * limits of the max and min receive packet sizes and do
7996 8021           * not exceed system limit.
7997 8022           */
7998 8023          ASSERT((rmax >= 0) || (rmax == INFPSZ));
7999 8024          if (rmax == 0) {
8000 8025                  freemsg(mctl);
8001 8026                  return (ERANGE);
8002 8027          }
8003 8028          /*
8004 8029           * Use the MAXIMUM of sd_maxblk and q_maxpsz.
8005 8030           * Needed to prevent partial failures in the strmakedata loop.
8006 8031           */
8007 8032          if (stp->sd_maxblk != INFPSZ && rmax != INFPSZ && rmax < stp->sd_maxblk)
8008 8033                  rmax = stp->sd_maxblk;
8009 8034  
8010 8035          if (uiop == NULL) {
8011 8036                  msgsize = -1;
8012 8037                  rmin = -1;      /* no range check for NULL data part */
8013 8038          } else {
8014 8039                  /* Use uio flags as well as the fmode parameter flags */
8015 8040                  fmode |= uiop->uio_fmode;
8016 8041  
8017 8042                  if ((msgsize < rmin) ||
8018 8043                      ((msgsize > rmax) && (rmax != INFPSZ))) {
8019 8044                          freemsg(mctl);
8020 8045                          return (ERANGE);
8021 8046                  }
8022 8047          }
8023 8048  
8024 8049          /* Ignore flow control in strput for HIPRI */
8025 8050          if (flag & MSG_HIPRI)
8026 8051                  flag |= MSG_IGNFLOW;
8027 8052  
8028 8053          for (;;) {
8029 8054                  int done = 0;
8030 8055                  int waitflag;
8031 8056                  mblk_t *mp;
8032 8057  
8033 8058                  /*
8034 8059                   * strput will always free the ctl mblk - even when strput
8035 8060                   * fails. If MSG_IGNFLOW is set then any error returned
8036 8061                   * will cause us to break the loop, so we don't need a copy
8037 8062                   * of the message. If MSG_IGNFLOW is not set, then we can
8038 8063                   * get hit by flow control and be forced to try again. In
8039 8064                   * this case we need to have a copy of the message. We
8040 8065                   * do this using copymsg since the message may get modified
8041 8066                   * by something below us.
8042 8067                   *
8043 8068                   * We've observed that many TPI providers do not check db_ref
8044 8069                   * on the control messages but blindly reuse them for the
8045 8070                   * T_OK_ACK/T_ERROR_ACK. Thus using copymsg is more
8046 8071                   * friendly to such providers than using dupmsg. Also, note
8047 8072                   * that sockfs uses MSG_IGNFLOW for all TPI control messages.
8048 8073                   * Only data messages are subject to flow control, hence
8049 8074                   * subject to this copymsg.
8050 8075                   */
8051 8076                  if (flag & MSG_IGNFLOW) {
8052 8077                          mp = mctl;
8053 8078                          mctl = NULL;
8054 8079                  } else {
8055 8080                          do {
8056 8081                                  /*
8057 8082                                   * If a message has a free pointer, the message
8058 8083                                   * must be dupmsg to maintain this pointer.
8059 8084                                   * Code using this facility must be sure
8060 8085                                   * that modules below will not change the
8061 8086                                   * contents of the dblk without checking db_ref
8062 8087                                   * first. If db_ref is > 1, then the module
8063 8088                                   * needs to do a copymsg first. Otherwise,
8064 8089                                   * the contents of the dblk may become
8065 8090                                   * inconsistent because the freesmg/freeb below
8066 8091                                   * may end up calling atomic_add_32_nv.
8067 8092                                   * The atomic_add_32_nv in freeb (accessing
8068 8093                                   * all of db_ref, db_type, db_flags, and
8069 8094                                   * db_struioflag) does not prevent other threads
8070 8095                                   * from concurrently trying to modify e.g.
8071 8096                                   * db_type.
8072 8097                                   */
8073 8098                                  if (mctl->b_datap->db_frtnp != NULL)
8074 8099                                          mp = dupmsg(mctl);
8075 8100                                  else
8076 8101                                          mp = copymsg(mctl);
8077 8102  
8078 8103                                  if (mp != NULL)
8079 8104                                          break;
8080 8105  
8081 8106                                  error = strwaitbuf(msgdsize(mctl), BPRI_MED);
8082 8107                                  if (error) {
8083 8108                                          freemsg(mctl);
8084 8109                                          return (error);
8085 8110                                  }
8086 8111                          } while (mp == NULL);
8087 8112                  }
8088 8113                  /*
8089 8114                   * Verify that all of msgsize can be transferred by
8090 8115                   * strput.
8091 8116                   */
8092 8117                  ASSERT(stp->sd_maxblk == INFPSZ || stp->sd_maxblk >= msgsize);
8093 8118                  error = strput(stp, mp, uiop, &msgsize, 0, pri, flag);
8094 8119                  if (error == 0)
8095 8120                          break;
8096 8121  
8097 8122                  if (error != EWOULDBLOCK)
8098 8123                          goto out;
8099 8124  
8100 8125                  /*
8101 8126                   * IF MSG_IGNFLOW is set we should have broken out of loop
8102 8127                   * above.
8103 8128                   */
8104 8129                  ASSERT(!(flag & MSG_IGNFLOW));
8105 8130                  mutex_enter(&stp->sd_lock);
8106 8131                  /*
8107 8132                   * Check for a missed wakeup.
8108 8133                   * Needed since strput did not hold sd_lock across
8109 8134                   * the canputnext.
8110 8135                   */
8111 8136                  if (bcanputnext(wqp, pri)) {
8112 8137                          /* Try again */
8113 8138                          mutex_exit(&stp->sd_lock);
8114 8139                          continue;
8115 8140                  }
8116 8141                  TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_WAIT,
8117 8142                      "kstrputmsg wait:stp %p waits pri %d", stp, pri);
8118 8143  
8119 8144                  waitflag = WRITEWAIT;
8120 8145                  if (flag & (MSG_HOLDSIG|MSG_IGNERROR)) {
8121 8146                          if (flag & MSG_HOLDSIG)
8122 8147                                  waitflag |= STR_NOSIG;
8123 8148                          if (flag & MSG_IGNERROR)
8124 8149                                  waitflag |= STR_NOERROR;
8125 8150                  }
8126 8151                  if (((error = strwaitq(stp, waitflag,
8127 8152                      (ssize_t)0, fmode, -1, &done)) != 0) || done) {
8128 8153                          mutex_exit(&stp->sd_lock);
8129 8154                          TRACE_3(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_OUT,
8130 8155                              "kstrputmsg out:stp %p out %d error %d",
8131 8156                              stp, 0, error);
8132 8157                          freemsg(mctl);
8133 8158                          return (error);
8134 8159                  }
8135 8160                  TRACE_1(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_WAKE,
8136 8161                      "kstrputmsg wake:stp %p wakes", stp);
8137 8162                  if ((error = i_straccess(stp, JCWRITE)) != 0) {
8138 8163                          mutex_exit(&stp->sd_lock);
8139 8164                          freemsg(mctl);
8140 8165                          return (error);
8141 8166                  }
8142 8167                  mutex_exit(&stp->sd_lock);
8143 8168          }
8144 8169  out:
8145 8170          freemsg(mctl);
8146 8171          /*
8147 8172           * For historic reasons, applications expect EAGAIN
8148 8173           * when data mblk could not be allocated. so change
8149 8174           * ENOMEM back to EAGAIN
8150 8175           */
8151 8176          if (error == ENOMEM)
8152 8177                  error = EAGAIN;
8153 8178          TRACE_3(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_OUT,
8154 8179              "kstrputmsg out:stp %p out %d error %d", stp, 2, error);
8155 8180          return (error);
8156 8181  }
8157 8182  
8158 8183  /*
8159 8184   * Determines whether the necessary conditions are set on a stream
8160 8185   * for it to be readable, writeable, or have exceptions.
8161 8186   *
8162 8187   * strpoll handles the consolidation private events:
8163 8188   *      POLLNOERR       Do not return POLLERR even if there are stream
8164 8189   *                      head errors.
8165 8190   *                      Used by sockfs.
8166 8191   *      POLLRDDATA      Do not return POLLIN unless at least one message on
8167 8192   *                      the queue contains one or more M_DATA mblks. Thus
8168 8193   *                      when this flag is set a queue with only
8169 8194   *                      M_PROTO/M_PCPROTO mblks does not return POLLIN.
8170 8195   *                      Used by sockfs to ignore T_EXDATA_IND messages.
8171 8196   *
8172 8197   * Note: POLLRDDATA assumes that synch streams only return messages with
8173 8198   * an M_DATA attached (i.e. not messages consisting of only
8174 8199   * an M_PROTO/M_PCPROTO part).
8175 8200   */
8176 8201  int
8177 8202  strpoll(struct stdata *stp, short events_arg, int anyyet, short *reventsp,
8178 8203      struct pollhead **phpp)
8179 8204  {
8180 8205          int events = (ushort_t)events_arg;
8181 8206          int retevents = 0;
8182 8207          mblk_t *mp;
8183 8208          qband_t *qbp;
8184 8209          long sd_flags = stp->sd_flag;
8185 8210          int headlocked = 0;
8186 8211  
8187 8212          /*
8188 8213           * For performance, a single 'if' tests for most possible edge
8189 8214           * conditions in one shot
8190 8215           */
8191 8216          if (sd_flags & (STPLEX | STRDERR | STWRERR)) {
8192 8217                  if (sd_flags & STPLEX) {
8193 8218                          *reventsp = POLLNVAL;
8194 8219                          return (EINVAL);
8195 8220                  }
8196 8221                  if (((events & (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI)) &&
8197 8222                      (sd_flags & STRDERR)) ||
8198 8223                      ((events & (POLLOUT | POLLWRNORM | POLLWRBAND)) &&
8199 8224                      (sd_flags & STWRERR))) {
8200 8225                          if (!(events & POLLNOERR)) {
8201 8226                                  *reventsp = POLLERR;
8202 8227                                  return (0);
8203 8228                          }
8204 8229                  }
8205 8230          }
8206 8231          if (sd_flags & STRHUP) {
8207 8232                  retevents |= POLLHUP;
8208 8233          } else if (events & (POLLWRNORM | POLLWRBAND)) {
8209 8234                  queue_t *tq;
8210 8235                  queue_t *qp = stp->sd_wrq;
8211 8236  
8212 8237                  claimstr(qp);
8213 8238                  /* Find next module forward that has a service procedure */
8214 8239                  tq = qp->q_next->q_nfsrv;
8215 8240                  ASSERT(tq != NULL);
8216 8241  
8217 8242                  if (polllock(&stp->sd_pollist, QLOCK(tq)) != 0) {
8218 8243                          releasestr(qp);
8219 8244                          *reventsp = POLLNVAL;
8220 8245                          return (0);
8221 8246                  }
8222 8247                  if (events & POLLWRNORM) {
8223 8248                          queue_t *sqp;
8224 8249  
8225 8250                          if (tq->q_flag & QFULL)
8226 8251                                  /* ensure backq svc procedure runs */
8227 8252                                  tq->q_flag |= QWANTW;
8228 8253                          else if ((sqp = stp->sd_struiowrq) != NULL) {
8229 8254                                  /* Check sync stream barrier write q */
8230 8255                                  mutex_exit(QLOCK(tq));
8231 8256                                  if (polllock(&stp->sd_pollist,
8232 8257                                      QLOCK(sqp)) != 0) {
8233 8258                                          releasestr(qp);
8234 8259                                          *reventsp = POLLNVAL;
8235 8260                                          return (0);
8236 8261                                  }
8237 8262                                  if (sqp->q_flag & QFULL)
8238 8263                                          /* ensure pollwakeup() is done */
8239 8264                                          sqp->q_flag |= QWANTWSYNC;
8240 8265                                  else
8241 8266                                          retevents |= POLLOUT;
8242 8267                                  /* More write events to process ??? */
8243 8268                                  if (! (events & POLLWRBAND)) {
8244 8269                                          mutex_exit(QLOCK(sqp));
8245 8270                                          releasestr(qp);
8246 8271                                          goto chkrd;
8247 8272                                  }
8248 8273                                  mutex_exit(QLOCK(sqp));
8249 8274                                  if (polllock(&stp->sd_pollist,
8250 8275                                      QLOCK(tq)) != 0) {
8251 8276                                          releasestr(qp);
8252 8277                                          *reventsp = POLLNVAL;
8253 8278                                          return (0);
8254 8279                                  }
8255 8280                          } else
8256 8281                                  retevents |= POLLOUT;
8257 8282                  }
8258 8283                  if (events & POLLWRBAND) {
8259 8284                          qbp = tq->q_bandp;
8260 8285                          if (qbp) {
8261 8286                                  while (qbp) {
8262 8287                                          if (qbp->qb_flag & QB_FULL)
8263 8288                                                  qbp->qb_flag |= QB_WANTW;
8264 8289                                          else
8265 8290                                                  retevents |= POLLWRBAND;
8266 8291                                          qbp = qbp->qb_next;
8267 8292                                  }
8268 8293                          } else {
8269 8294                                  retevents |= POLLWRBAND;
8270 8295                          }
8271 8296                  }
8272 8297                  mutex_exit(QLOCK(tq));
8273 8298                  releasestr(qp);
8274 8299          }
8275 8300  chkrd:
8276 8301          if (sd_flags & STRPRI) {
8277 8302                  retevents |= (events & POLLPRI);
8278 8303          } else if (events & (POLLRDNORM | POLLRDBAND | POLLIN)) {
8279 8304                  queue_t *qp = _RD(stp->sd_wrq);
8280 8305                  int normevents = (events & (POLLIN | POLLRDNORM));
8281 8306  
8282 8307                  /*
8283 8308                   * Note: Need to do polllock() here since ps_lock may be
8284 8309                   * held. See bug 4191544.
8285 8310                   */
8286 8311                  if (polllock(&stp->sd_pollist, &stp->sd_lock) != 0) {
8287 8312                          *reventsp = POLLNVAL;
8288 8313                          return (0);
8289 8314                  }
8290 8315                  headlocked = 1;
8291 8316                  mp = qp->q_first;
8292 8317                  while (mp) {
8293 8318                          /*
8294 8319                           * For POLLRDDATA we scan b_cont and b_next until we
8295 8320                           * find an M_DATA.
8296 8321                           */
8297 8322                          if ((events & POLLRDDATA) &&
8298 8323                              mp->b_datap->db_type != M_DATA) {
8299 8324                                  mblk_t *nmp = mp->b_cont;
8300 8325  
8301 8326                                  while (nmp != NULL &&
8302 8327                                      nmp->b_datap->db_type != M_DATA)
8303 8328                                          nmp = nmp->b_cont;
8304 8329                                  if (nmp == NULL) {
8305 8330                                          mp = mp->b_next;
8306 8331                                          continue;
8307 8332                                  }
8308 8333                          }
8309 8334                          if (mp->b_band == 0)
8310 8335                                  retevents |= normevents;
8311 8336                          else
8312 8337                                  retevents |= (events & (POLLIN | POLLRDBAND));
8313 8338                          break;
8314 8339                  }
8315 8340                  if (!(retevents & normevents) && (stp->sd_wakeq & RSLEEP)) {
8316 8341                          /*
8317 8342                           * Sync stream barrier read queue has data.
8318 8343                           */
8319 8344                          retevents |= normevents;
8320 8345                  }
8321 8346                  /* Treat eof as normal data */
8322 8347                  if (sd_flags & STREOF)
8323 8348                          retevents |= normevents;
8324 8349          }
8325 8350  
8326 8351          /*
8327 8352           * Pass back a pollhead if no events are pending or if edge-triggering
8328 8353           * has been configured on this resource.
8329 8354           */
8330 8355          if ((retevents == 0 && !anyyet) || (events & POLLET)) {
8331 8356                  *phpp = &stp->sd_pollist;
8332 8357                  if (headlocked == 0) {
8333 8358                          if (polllock(&stp->sd_pollist, &stp->sd_lock) != 0) {
8334 8359                                  *reventsp = POLLNVAL;
8335 8360                                  return (0);
8336 8361                          }
8337 8362                          headlocked = 1;
8338 8363                  }
8339 8364                  stp->sd_rput_opt |= SR_POLLIN;
8340 8365          }
8341 8366  
8342 8367          *reventsp = (short)retevents;
8343 8368          if (headlocked)
8344 8369                  mutex_exit(&stp->sd_lock);
8345 8370          return (0);
8346 8371  }
8347 8372  
8348 8373  /*
8349 8374   * The purpose of putback() is to assure sleeping polls/reads
8350 8375   * are awakened when there are no new messages arriving at the,
8351 8376   * stream head, and a message is placed back on the read queue.
8352 8377   *
8353 8378   * sd_lock must be held when messages are placed back on stream
8354 8379   * head.  (getq() holds sd_lock when it removes messages from
8355 8380   * the queue)
8356 8381   */
8357 8382  
8358 8383  static void
8359 8384  putback(struct stdata *stp, queue_t *q, mblk_t *bp, int band)
8360 8385  {
8361 8386          mblk_t  *qfirst;
8362 8387          ASSERT(MUTEX_HELD(&stp->sd_lock));
8363 8388  
8364 8389          /*
8365 8390           * As a result of lock-step ordering around q_lock and sd_lock,
8366 8391           * it's possible for function calls like putnext() and
8367 8392           * canputnext() to get an inaccurate picture of how much
8368 8393           * data is really being processed at the stream head.
8369 8394           * We only consolidate with existing messages on the queue
8370 8395           * if the length of the message we want to put back is smaller
8371 8396           * than the queue hiwater mark.
8372 8397           */
8373 8398          if ((stp->sd_rput_opt & SR_CONSOL_DATA) &&
8374 8399              (DB_TYPE(bp) == M_DATA) && ((qfirst = q->q_first) != NULL) &&
8375 8400              (DB_TYPE(qfirst) == M_DATA) &&
8376 8401              ((qfirst->b_flag & (MSGMARK|MSGDELIM)) == 0) &&
8377 8402              ((bp->b_flag & (MSGMARK|MSGDELIM|MSGMARKNEXT)) == 0) &&
8378 8403              (mp_cont_len(bp, NULL) < q->q_hiwat)) {
8379 8404                  /*
8380 8405                   * We use the same logic as defined in strrput()
8381 8406                   * but in reverse as we are putting back onto the
8382 8407                   * queue and want to retain byte ordering.
8383 8408                   * Consolidate M_DATA messages with M_DATA ONLY.
8384 8409                   * strrput() allows the consolidation of M_DATA onto
8385 8410                   * M_PROTO | M_PCPROTO but not the other way round.
8386 8411                   *
8387 8412                   * The consolidation does not take place if the message
8388 8413                   * we are returning to the queue is marked with either
8389 8414                   * of the marks or the delim flag or if q_first
8390 8415                   * is marked with MSGMARK. The MSGMARK check is needed to
8391 8416                   * handle the odd semantics of MSGMARK where essentially
8392 8417                   * the whole message is to be treated as marked.
8393 8418                   * Carry any MSGMARKNEXT and MSGNOTMARKNEXT from q_first
8394 8419                   * to the front of the b_cont chain.
8395 8420                   */
8396 8421                  rmvq_noenab(q, qfirst);
8397 8422  
8398 8423                  /*
8399 8424                   * The first message in the b_cont list
8400 8425                   * tracks MSGMARKNEXT and MSGNOTMARKNEXT.
8401 8426                   * We need to handle the case where we
8402 8427                   * are appending:
8403 8428                   *
8404 8429                   * 1) a MSGMARKNEXT to a MSGNOTMARKNEXT.
8405 8430                   * 2) a MSGMARKNEXT to a plain message.
8406 8431                   * 3) a MSGNOTMARKNEXT to a plain message
8407 8432                   * 4) a MSGNOTMARKNEXT to a MSGNOTMARKNEXT
8408 8433                   *    message.
8409 8434                   *
8410 8435                   * Thus we never append a MSGMARKNEXT or
8411 8436                   * MSGNOTMARKNEXT to a MSGMARKNEXT message.
8412 8437                   */
8413 8438                  if (qfirst->b_flag & MSGMARKNEXT) {
8414 8439                          bp->b_flag |= MSGMARKNEXT;
8415 8440                          bp->b_flag &= ~MSGNOTMARKNEXT;
8416 8441                          qfirst->b_flag &= ~MSGMARKNEXT;
8417 8442                  } else if (qfirst->b_flag & MSGNOTMARKNEXT) {
8418 8443                          bp->b_flag |= MSGNOTMARKNEXT;
8419 8444                          qfirst->b_flag &= ~MSGNOTMARKNEXT;
8420 8445                  }
8421 8446  
8422 8447                  linkb(bp, qfirst);
8423 8448          }
8424 8449          (void) putbq(q, bp);
8425 8450  
8426 8451          /*
8427 8452           * A message may have come in when the sd_lock was dropped in the
8428 8453           * calling routine. If this is the case and STR*ATMARK info was
8429 8454           * received, need to move that from the stream head to the q_last
8430 8455           * so that SIOCATMARK can return the proper value.
8431 8456           */
8432 8457          if (stp->sd_flag & (STRATMARK | STRNOTATMARK)) {
8433 8458                  unsigned short *flagp = &q->q_last->b_flag;
8434 8459                  uint_t b_flag = (uint_t)*flagp;
8435 8460  
8436 8461                  if (stp->sd_flag & STRATMARK) {
8437 8462                          b_flag &= ~MSGNOTMARKNEXT;
8438 8463                          b_flag |= MSGMARKNEXT;
8439 8464                          stp->sd_flag &= ~STRATMARK;
8440 8465                  } else {
8441 8466                          b_flag &= ~MSGMARKNEXT;
8442 8467                          b_flag |= MSGNOTMARKNEXT;
8443 8468                          stp->sd_flag &= ~STRNOTATMARK;
8444 8469                  }
8445 8470                  *flagp = (unsigned short) b_flag;
8446 8471          }
8447 8472  
8448 8473  #ifdef  DEBUG
8449 8474          /*
8450 8475           * Make sure that the flags are not messed up.
8451 8476           */
8452 8477          {
8453 8478                  mblk_t *mp;
8454 8479                  mp = q->q_last;
8455 8480                  while (mp != NULL) {
8456 8481                          ASSERT((mp->b_flag & (MSGMARKNEXT|MSGNOTMARKNEXT)) !=
8457 8482                              (MSGMARKNEXT|MSGNOTMARKNEXT));
8458 8483                          mp = mp->b_cont;
8459 8484                  }
8460 8485          }
8461 8486  #endif
8462 8487          if (q->q_first == bp) {
8463 8488                  short pollevents;
8464 8489  
8465 8490                  if (stp->sd_flag & RSLEEP) {
8466 8491                          stp->sd_flag &= ~RSLEEP;
8467 8492                          cv_broadcast(&q->q_wait);
8468 8493                  }
8469 8494                  if (stp->sd_flag & STRPRI) {
8470 8495                          pollevents = POLLPRI;
8471 8496                  } else {
8472 8497                          if (band == 0) {
8473 8498                                  if (!(stp->sd_rput_opt & SR_POLLIN))
8474 8499                                          return;
8475 8500                                  stp->sd_rput_opt &= ~SR_POLLIN;
8476 8501                                  pollevents = POLLIN | POLLRDNORM;
8477 8502                          } else {
8478 8503                                  pollevents = POLLIN | POLLRDBAND;
8479 8504                          }
8480 8505                  }
8481 8506                  mutex_exit(&stp->sd_lock);
8482 8507                  pollwakeup(&stp->sd_pollist, pollevents);
8483 8508                  mutex_enter(&stp->sd_lock);
8484 8509          }
8485 8510  }
8486 8511  
8487 8512  /*
8488 8513   * Return the held vnode attached to the stream head of a
8489 8514   * given queue
8490 8515   * It is the responsibility of the calling routine to ensure
8491 8516   * that the queue does not go away (e.g. pop).
8492 8517   */
8493 8518  vnode_t *
8494 8519  strq2vp(queue_t *qp)
8495 8520  {
8496 8521          vnode_t *vp;
8497 8522          vp = STREAM(qp)->sd_vnode;
8498 8523          ASSERT(vp != NULL);
8499 8524          VN_HOLD(vp);
8500 8525          return (vp);
8501 8526  }
8502 8527  
8503 8528  /*
8504 8529   * return the stream head write queue for the given vp
8505 8530   * It is the responsibility of the calling routine to ensure
8506 8531   * that the stream or vnode do not close.
8507 8532   */
8508 8533  queue_t *
8509 8534  strvp2wq(vnode_t *vp)
8510 8535  {
8511 8536          ASSERT(vp->v_stream != NULL);
8512 8537          return (vp->v_stream->sd_wrq);
8513 8538  }
8514 8539  
8515 8540  /*
8516 8541   * pollwakeup stream head
8517 8542   * It is the responsibility of the calling routine to ensure
8518 8543   * that the stream or vnode do not close.
8519 8544   */
8520 8545  void
8521 8546  strpollwakeup(vnode_t *vp, short event)
8522 8547  {
8523 8548          ASSERT(vp->v_stream);
8524 8549          pollwakeup(&vp->v_stream->sd_pollist, event);
8525 8550  }
8526 8551  
8527 8552  /*
8528 8553   * Mate the stream heads of two vnodes together. If the two vnodes are the
8529 8554   * same, we just make the write-side point at the read-side -- otherwise,
8530 8555   * we do a full mate.  Only works on vnodes associated with streams that are
8531 8556   * still being built and thus have only a stream head.
8532 8557   */
8533 8558  void
8534 8559  strmate(vnode_t *vp1, vnode_t *vp2)
8535 8560  {
8536 8561          queue_t *wrq1 = strvp2wq(vp1);
8537 8562          queue_t *wrq2 = strvp2wq(vp2);
8538 8563  
8539 8564          /*
8540 8565           * Verify that there are no modules on the stream yet.  We also
8541 8566           * rely on the stream head always having a service procedure to
8542 8567           * avoid tweaking q_nfsrv.
8543 8568           */
8544 8569          ASSERT(wrq1->q_next == NULL && wrq2->q_next == NULL);
8545 8570          ASSERT(wrq1->q_qinfo->qi_srvp != NULL);
8546 8571          ASSERT(wrq2->q_qinfo->qi_srvp != NULL);
8547 8572  
8548 8573          /*
8549 8574           * If the queues are the same, just twist; otherwise do a full mate.
8550 8575           */
8551 8576          if (wrq1 == wrq2) {
8552 8577                  wrq1->q_next = _RD(wrq1);
8553 8578          } else {
8554 8579                  wrq1->q_next = _RD(wrq2);
8555 8580                  wrq2->q_next = _RD(wrq1);
8556 8581                  STREAM(wrq1)->sd_mate = STREAM(wrq2);
8557 8582                  STREAM(wrq1)->sd_flag |= STRMATE;
8558 8583                  STREAM(wrq2)->sd_mate = STREAM(wrq1);
8559 8584                  STREAM(wrq2)->sd_flag |= STRMATE;
8560 8585          }
8561 8586  }
8562 8587  
8563 8588  /*
8564 8589   * XXX will go away when console is correctly fixed.
8565 8590   * Clean up the console PIDS, from previous I_SETSIG,
8566 8591   * called only for cnopen which never calls strclean().
8567 8592   */
8568 8593  void
8569 8594  str_cn_clean(struct vnode *vp)
8570 8595  {
8571 8596          strsig_t *ssp, *pssp, *tssp;
8572 8597          struct stdata *stp;
8573 8598          struct pid  *pidp;
8574 8599          int update = 0;
8575 8600  
8576 8601          ASSERT(vp->v_stream);
8577 8602          stp = vp->v_stream;
8578 8603          pssp = NULL;
8579 8604          mutex_enter(&stp->sd_lock);
8580 8605          ssp = stp->sd_siglist;
8581 8606          while (ssp) {
8582 8607                  mutex_enter(&pidlock);
8583 8608                  pidp = ssp->ss_pidp;
8584 8609                  /*
8585 8610                   * Get rid of PID if the proc is gone.
8586 8611                   */
8587 8612                  if (pidp->pid_prinactive) {
8588 8613                          tssp = ssp->ss_next;
8589 8614                          if (pssp)
8590 8615                                  pssp->ss_next = tssp;
8591 8616                          else
8592 8617                                  stp->sd_siglist = tssp;
8593 8618                          ASSERT(pidp->pid_ref <= 1);
8594 8619                          PID_RELE(ssp->ss_pidp);
8595 8620                          mutex_exit(&pidlock);
8596 8621                          kmem_free(ssp, sizeof (strsig_t));
8597 8622                          update = 1;
8598 8623                          ssp = tssp;
8599 8624                          continue;
8600 8625                  } else
8601 8626                          mutex_exit(&pidlock);
8602 8627                  pssp = ssp;
8603 8628                  ssp = ssp->ss_next;
8604 8629          }
8605 8630          if (update) {
8606 8631                  stp->sd_sigflags = 0;
8607 8632                  for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
8608 8633                          stp->sd_sigflags |= ssp->ss_events;
8609 8634          }
8610 8635          mutex_exit(&stp->sd_lock);
8611 8636  }
8612 8637  
8613 8638  /*
8614 8639   * Return B_TRUE if there is data in the message, B_FALSE otherwise.
8615 8640   */
8616 8641  static boolean_t
8617 8642  msghasdata(mblk_t *bp)
8618 8643  {
8619 8644          for (; bp; bp = bp->b_cont)
8620 8645                  if (bp->b_datap->db_type == M_DATA) {
8621 8646                          ASSERT(bp->b_wptr >= bp->b_rptr);
8622 8647                          if (bp->b_wptr > bp->b_rptr)
8623 8648                                  return (B_TRUE);
8624 8649                  }
8625 8650          return (B_FALSE);
8626 8651  }
  
    | 
      ↓ open down ↓ | 
    4831 lines elided | 
    
      ↑ open up ↑ | 
  
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX