src/mt/ss_strm.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18 \f
  19 /********************************************************************20**
  20
  21      Name:     System Services -- STREAMS
  22
  23      Type:     C source file
  24
  25      Desc:     Implementation of STREAMS messaging functions.
  26
  27      File:     ss_strm.c
  28
  29 *********************************************************************21*/
  30
  31 \f
  32 /* header include files (.h) */
  33
  34 #include "envopt.h"        /* environment options */
  35 #include "envdep.h"        /* environment dependent */
  36 #include "envind.h"        /* environment independent */
  37
  38 #include "gen.h"           /* general layer */
  39 #include "ssi.h"           /* system services */
  40
  41 #include "ss_err.h"        /* errors */
  42 #include "ss_dep.h"        /* implementation-specific */
  43 #include "ss_queue.h"      /* queues */
  44 #include "ss_strm.h"       /* STREAMS */
  45 #include "ss_msg.h"        /* messaging */
  46 #include "ss_mem.h"        /* memory management interface */
  47 #include "ss_gen.h"        /* general */
  48 #include "cm_mem.h"        /* memory management */
  49
  50
  51
  52 /* header/extern include files (.x) */
  53
  54 #include "gen.x"           /* general layer */
  55 #include "ssi.x"           /* system services */
  56
  57
  58 #include "ss_dep.x"        /* implementation-specific */
  59 #include "ss_queue.x"      /* queues */
  60 #include "ss_task.x"       /* tasking */
  61 #include "ss_timer.x"      /* timers */
  62 #include "ss_strm.x"       /* STREAMS */
  63 #include "ss_msg.x"        /* messaging */
  64 #include "ss_mem.x"        /* memory management interface */
  65 #include "ss_drvr.x"       /* driver tasks */
  66 #ifdef SS_LOCKLESS_MEMORY
  67 #include "cm_llist.x"
  68 #include "cm_hash.x"
  69 #include "cm_mem_wl.x"        /* common memory manager */
  70 #else
  71 #include "cm_mem.x"        /* common memory manager */
  72 #endif /* SS_LOCKLESS_MEMORY */
  73 #include "ss_gen.x"        /* general */
  74
  75
  76 \f
  77 /* private variable declarations */
  78
  79 static struct
  80 {
  81    Region mdRegion;     /* region for message and data blocks */
  82    Region datRegion;    /* region for data buffers */
  83 } strmCfg;
  84
  85
  86
  87 \f
  88 /*
  89 *     Interface functions (System Services--non-STREAMS interface)
  90 */
  91
  92 \f
  93 /*
  94 *
  95 *       Fun:   ssStrmCfg
  96 *
  97 *       Desc:  Configures the STREAMS system.
  98 *
  99 *       Ret:   ROK      - ok
 100 *
 101 *       Notes:
 102 *
 103 *       File:  ss_strm.c
 104 *
 105 */
 106 S16 ssStrmCfg
 107 (
 108 Region mdRegId,                 /* region for message and data blocks */
 109 Region datRegId                 /* region for data buffers */
 110 )
 111 {
 112
 113    strmCfg.mdRegion = mdRegId;
 114    strmCfg.datRegion = datRegId;
 115
 116
 117    return ROK;
 118 }
 119
 120 \f
 121 /*
 122 *     STREAMS interface functions
 123 *
 124 *       All these assume that ssStrmCfg() has been called first, with
 125 *       valid parameters.
 126 */
 127
 128 \f
 129 /*
 130 *
 131 *       Fun:   ssAdjMsg
 132 *
 133 *       Desc:  Trim abs(len) bytes from a message. If len is less than
 134 *              0, trim from the tail, otherwise from the head. Operates
 135 *              only on blocks of the same type. Does not remove emptied
 136 *              message blocks.
 137 *
 138 *
 139 *       Ret:   1        - ok
 140 *              0        - failure
 141 *
 142 *       Notes:
 143 *
 144 *       File:  ss_strm.c
 145 *
 146 */
 147 S32 ssAdjMsg
 148 (
 149 SsMblk *mp,                     /* message */
 150 S32 len                         /* bytes to remove */
 151 )
 152 {
 153    S32 n;                       /* counter */
 154    S32 size;                    /* size of mblks of same type as head/tail */
 155    uint8_t type;                     /* message type */
 156    SsMblk *bp;                  /* mblk for iteration */
 157    SsMblk *first;               /* first mblk to be adjusted */
 158
 159 #if (ERRCLASS & ERRCLS_INT_PAR)
 160    if (mp == NULLP)
 161    {
 162       SSLOGERROR(ERRCLS_INT_PAR, ESS325, ERRZERO, "Null pointer");
 163       return (0);
 164    }
 165 #endif
 166
 167
 168    if (len == 0)                /* nothing to do */
 169    {
 170       return (1);
 171    }
 172
 173
 174    if (len > 0)                 /* trim from the head */
 175    {
 176       /* figure out the size of all blocks of the same type as the head */
 177       bp = mp;
 178       size = 0;
 179       type = bp->b_datap->db_type;
 180       while (bp  &&  bp->b_datap->db_type == type)
 181       {
 182          n = bp->b_wptr - bp->b_rptr;
 183          if (n > 0)
 184          {
 185             size += n;
 186          }
 187
 188          bp = bp->b_cont;
 189       }
 190
 191
 192       /* if we can't trim len bytes, fail */
 193       if (len > size)
 194       {
 195          return (0);
 196       }
 197
 198
 199       /* do the trimming */
 200       bp = mp;
 201       for (; ;)
 202       {
 203          n = bp->b_wptr - bp->b_rptr;
 204
 205          if (n >= len)
 206          {
 207             bp->b_rptr += len;
 208             break;
 209          }
 210          else if (n > 0)
 211          {
 212             bp->b_rptr += len;
 213             len -= n;
 214          }
 215
 216          bp = bp->b_cont;
 217       }
 218    }
 219    else                         /* trim from the tail */
 220    {
 221       /* figure out the size of all blocks of the same type as the tail */
 222       bp = mp;
 223       first = bp;
 224       size = 0;
 225       type = bp->b_datap->db_type;
 226       while (bp)
 227       {
 228          if (bp->b_datap->db_type == type)
 229          {
 230             n = bp->b_wptr - bp->b_rptr;
 231             if (n > 0)
 232             {
 233                size += n;
 234             }
 235          }
 236          else
 237          {
 238             type = bp->b_datap->db_type;
 239             first = bp;
 240             size = 0;
 241          }
 242
 243          bp = bp->b_cont;
 244       }
 245
 246
 247       /* if we can't trim len bytes, fail */
 248       size += len;
 249       if (size < 0)
 250       {
 251          return (0);
 252       }
 253
 254
 255       /* do the trimming */
 256       while (first)
 257       {
 258          n = first->b_wptr - first->b_rptr;
 259
 260          if (size <= 0)
 261          {
 262             first->b_rptr = first->b_wptr;
 263          }
 264          else if (n > 0)
 265          {
 266             if (n > size)
 267             {
 268                first->b_wptr = first->b_rptr + size;
 269             }
 270
 271             size -= n;
 272          }
 273
 274          first = first->b_cont;
 275       }
 276    }
 277
 278
 279    return (1);
 280 } /* ssAdjMsg */
 281
 282 \f
 283 /*
 284 *
 285 *       Fun:   ssAllocB
 286 *
 287 *       Desc:  Returns a pointer to a message block of type M_DATA
 288 *              in which the data buffer is of at least the specified
 289 *              size.
 290 *
 291 *
 292 *       Ret:   non-NULL - success
 293 *              NULL     - failure
 294 *
 295 *       Notes: The parameter pri is unused.
 296 *
 297 *       File:  ss_strm.c
 298 *
 299 */
 300 SsMblk *ssAllocB
 301 (
 302 S32 size,                       /* required size */
 303 uint32_t pri                         /* message priority */
 304 )
 305 {
 306    SsMblk *bp;                  /* mblk for iteration */
 307    Data *dat;                   /* pointer to data buffer */
 308    Size m;                      /* temporary */
 309    Size n;                      /* temporary */
 310    S16 r;                       /* return value */
 311
 312
 313 #ifdef T2K_MEM_LEAK_DBG
 314    char* file = __FILE__;
 315    uint32_t line = __LINE__;
 316 #endif
 317
 318    UNUSED(pri);
 319
 320
 321    /* allocate a single block for the mblock and the dblock */
 322    m = (sizeof(SsMblk) + sizeof(SsDblk));
 323 /* ss001.301: additions */
 324 #ifdef SS_HISTOGRAM_SUPPORT
 325    r = SAlloc(strmCfg.mdRegion, &m, 0, (Data **)&bp, __LINE__, (uint8_t*)__FILE__, ENTNC);
 326 #else
 327    r = SAlloc(strmCfg.mdRegion, &m, 0, (Data **)&bp);
 328 #endif /* SS_HISTOGRAM_SUPPORT */
 329    if (r != ROK)
 330    {
 331 #if (ERRCLASS & ERRCLS_ADD_RES)
 332       SSLOGERROR(ERRCLS_ADD_RES, ESS326, (ErrVal) r, "SAlloc() failed");
 333 #endif
 334
 335       return (NULLP);
 336    }
 337
 338
 339    /* allocate space for the data block */
 340    if (size > 0)
 341    {
 342       n = size;
 343 /* ss001.301: additions */
 344 #ifdef SS_HISTOGRAM_SUPPORT
 345       r = SAlloc(strmCfg.datRegion, &n, 0, &dat, __LINE__, (uint8_t*)__FILE__, ENTNC);
 346 #else
 347       r = SAlloc(strmCfg.datRegion, &n, 0, &dat);
 348 #endif /* SS_HISTOGRAM_SUPPORT */
 349       if (r != ROK)
 350       {
 351 #if (ERRCLASS & ERRCLS_ADD_RES)
 352          SSLOGERROR(ERRCLS_ADD_RES, ESS327, (ErrVal) r, "SAlloc() failed");
 353 #endif
 354
 355 /* ss001.301: additions */
 356 #ifdef SS_HISTOGRAM_SUPPORT
 357          SFree(strmCfg.mdRegion, (Data *)bp, m, __LINE__, (uint8_t*)__FILE__, ENTNC);
 358 #else
 359          SFree(strmCfg.mdRegion, (Data *)bp, m);
 360 #endif /* SS_HISTOGRAM_SUPPORT */
 361          return (NULLP);
 362       }
 363    }
 364    /* we _can_ allocate a message with an empty data block */
 365    else
 366    {
 367       dat = NULLP;
 368    }
 369
 370    /* generic set-up-message function */
 371    SS_STRM_INITB(bp, (SsDblk *)(((uint8_t *)bp) + sizeof(SsMblk)), dat, size, NULLP);
 372
 373
 374    return (bp);
 375 } /* ssAllocB */
 376
 377 \f
 378 /*
 379 *
 380 *       Fun:   ssCopyB
 381 *
 382 *       Desc:  Copies the contents of the specified message block
 383 *              into a newly-allocated message block of at least
 384 *              the same size. Calls ssAllocB().
 385 *
 386 *       Ret:   non-NULL - ok
 387 *              NULL     - failure
 388 *
 389 *       Notes:
 390 *
 391 *       File:  ss_strm.c
 392 *
 393 */
 394 SsMblk *ssCopyB
 395 (
 396 SsMblk *mp                      /* message block */
 397 )
 398 {
 399    SsMblk *bp;                  /* mblk for iteration */
 400    uint8_t *ptr;                     /* pointer to data */
 401    uint32_t size;                    /* size of data content */
 402
 403
 404 #if (ERRCLASS & ERRCLS_INT_PAR)
 405    if (mp == NULLP)
 406    {
 407       SSLOGERROR(ERRCLS_INT_PAR, ESS328, ERRZERO, "Null pointer");
 408       return (NULLP);
 409    }
 410 #endif
 411
 412
 413    /* allocate another message */
 414    bp = ssAllocB((mp->b_datap->db_lim - mp->b_datap->db_base), 0);
 415    if (bp == NULLP)
 416    {
 417 #if (ERRCLASS & ERRCLS_ADD_RES)
 418       SSLOGERROR(ERRCLS_ADD_RES, ESS329, ERRZERO, "ssAllocB() failed");
 419 #endif
 420
 421       return (NULLP);
 422    }
 423
 424
 425    /* copy the contents, if any */
 426    size = (mp->b_wptr - mp->b_rptr);
 427    if (size > 0)
 428    {
 429       ptr = mp->b_rptr;
 430       while (ptr != mp->b_wptr)
 431       {
 432          *bp->b_wptr++ = *ptr++;
 433       }
 434    }
 435
 436
 437    return (bp);
 438 } /* ssCopyB */
 439
 440 \f
 441 /*
 442 *
 443 *       Fun:   ssCopyMsg
 444 *
 445 *       Desc:  Uses ssCopyB to copy the message blocks contained in
 446 *              the specified message to newly allocated blocks and
 447 *              links those blocks into a new message.
 448 *
 449 *       Ret:   non-NULL - ok
 450 *              NULL     - failure
 451 *
 452 *       Notes:
 453 *
 454 *       File:  ss_strm.c
 455 *
 456 */
 457 SsMblk *ssCopyMsg
 458 (
 459 SsMblk *mp                      /* message block */
 460 )
 461 {
 462    SsMblk *first;               /* first mblk in message */
 463    SsMblk *bp;                  /* mblk for iteration */
 464
 465 #if (ERRCLASS & ERRCLS_INT_PAR)
 466    if (mp == NULLP)
 467    {
 468       SSLOGERROR(ERRCLS_INT_PAR, ESS330, ERRZERO, "Null pointer");
 469       return (NULLP);
 470    }
 471 #endif
 472
 473
 474    /* copy the first mblock */
 475    first = bp = ssCopyB(mp);
 476    if (bp == NULLP)
 477    {
 478 #if (ERRCLASS & ERRCLS_ADD_RES)
 479       SSLOGERROR(ERRCLS_ADD_RES, ESS331, ERRZERO, "ssCopyB() failed");
 480 #endif
 481
 482       return (NULLP);
 483    }
 484
 485
 486    /* copy all the rest, linking the new ones at the same time */
 487    while (mp->b_cont)
 488    {
 489       mp = mp->b_cont;
 490
 491       bp->b_cont = ssCopyB(mp);
 492
 493       /* if any copy fails, free whatever exists of the new message */
 494       if (bp->b_cont == NULLP)
 495       {
 496 #if (ERRCLASS & ERRCLS_ADD_RES)
 497          SSLOGERROR(ERRCLS_ADD_RES, ESS332, ERRZERO, "ssCopyB() failed");
 498 #endif
 499
 500          ssFreeMsg(first);
 501          return (NULLP);
 502       }
 503
 504       bp = bp->b_cont;
 505    }
 506
 507
 508    return (first);
 509 } /* ssCopyMsg */
 510
 511 \f
 512 /*
 513 *
 514 *       Fun:   ssDupB
 515 *
 516 *       Desc:  Duplicates the specified message block, copying it
 517 *              into a newly-allocated message block. Increments
 518 *              the reference count of the data block that is pointed
 519 *              at by the original message block descriptor.
 520 *
 521 *       Ret:   non-NULL - ok
 522 *              NULL     - failure
 523 *
 524 *       Notes:
 525 *
 526 *       File:  ss_strm.c
 527 *
 528 */
 529 SsMblk *ssDupB
 530 (
 531 SsMblk *mp                      /* message block */
 532 )
 533 {
 534    SsMblk *bp;                  /* mblk for iteration */
 535    /* ss028.103 - Addition of lock for mBuf reference count */
 536
 537 #if (ERRCLASS & ERRCLS_INT_PAR)
 538    if (mp == NULLP)
 539    {
 540       SSLOGERROR(ERRCLS_INT_PAR, ESS333, ERRZERO, "Null pointer");
 541       return (NULLP);
 542    }
 543 #endif
 544
 545
 546    /* allocate a message with no data buffer */
 547    bp = ssAllocB(0, 0);
 548    if (bp == NULLP)
 549    {
 550 #if (ERRCLASS & ERRCLS_ADD_RES)
 551       SSLOGERROR(ERRCLS_ADD_RES, ESS334, ERRZERO, "ssAllocB() failed");
 552 #endif
 553
 554       return (NULLP);
 555    }
 556
 557
 558    /*  make the new message block identical to the one to be dup'ed.
 559     *  notice that an mblk/dblk pair is allocated but only the mblk
 560     *  is used,, this is for optimum performance in the average case.
 561     */
 562
 563
 564
 565  /* ss002.13: addition */
 566
 567
 568  /* ss003.13: addition */
 569    SMemCpy( (Void *)bp, (Void *)mp, (size_t)sizeof(SsMblk));
 570
 571
 572    /* ss028.103 - Addition of lock for mBuf reference count */
 573         /* ss006.301 - use the mBufRefLock for the DFLT_REGION */
 574 #ifndef SS_DBUF_REFLOCK_DISABLE
 575    if(SLock(&mp->b_datap->dBufLock) != ROK)
 576    {
 577       SSLOGERROR(ERRCLS_DEBUG, ESS335, ERRZERO,
 578                      "Could not lock the mBuf Ref Lock");
 579       return (NULLP);
 580    }
 581 #endif
 582
 583    /* increment the reference count of the dblock */
 584    mp->b_datap->db_ref++;
 585    mp->b_datap->shared = TRUE;
 586
 587         /* ss006.301 - use the mBufRefLock for the DFLT_REGION */
 588 #ifndef SS_DBUF_REFLOCK_DISABLE
 589    if ( SUnlock(&mp->b_datap->dBufLock) != ROK)
 590    {
 591 #if (ERRCLASS & ERRCLS_DEBUG)
 592       SSLOGERROR(ERRCLS_DEBUG, ESS336, ERRZERO,
 593                       "Could not give the Semaphore");
 594       return (NULLP);
 595 #endif
 596    }
 597 #endif
 598
 599    return (bp);
 600 } /* ssDupB */
 601
 602 \f
 603 /*
 604 *
 605 *       Fun:   ssDupMsg
 606 *
 607 *       Desc:  Calls ssDupB to duplicate the specified message by
 608 *              copying all message block descriptors and then linking
 609 *              the new message blocks together to form a new message.
 610 *
 611 *       Ret:   non-NULL - ok
 612 *              NULL     - failure
 613 *
 614 *       Notes:
 615 *
 616 *       File:  ss_strm.c
 617 *
 618 */
 619 SsMblk *ssDupMsg
 620 (
 621 SsMblk *mp                      /* message block */
 622 )
 623 {
 624    SsMblk *first;               /* first mblk in message */
 625    SsMblk *bp;                  /* mblk for iteration */
 626
 627    /* dup the first mblock */
 628    first = bp = ssDupB(mp);
 629    if (bp == NULLP)
 630    {
 631 #if (ERRCLASS & ERRCLS_ADD_RES)
 632       SSLOGERROR(ERRCLS_ADD_RES, ESS337, ERRZERO, "ssDupB() failed");
 633 #endif
 634
 635       return (NULLP);
 636    }
 637
 638
 639    /* dup all the rest, linking the new ones at the same time */
 640    while (mp->b_cont)
 641    {
 642       mp = mp->b_cont;
 643
 644       bp->b_cont = ssDupB(mp);
 645
 646       /* if any dup fails, free whatever exists of the new message */
 647       if (bp->b_cont == NULLP)
 648       {
 649 #if (ERRCLASS & ERRCLS_ADD_RES)
 650          SSLOGERROR(ERRCLS_ADD_RES, ESS338, ERRZERO, "ssDupB() failed");
 651 #endif
 652
 653          ssFreeMsg(first);
 654          return (NULLP);
 655       }
 656
 657       bp = bp->b_cont;
 658    }
 659
 660
 661    return (first);
 662 } /* ssDupMsg */
 663
 664 \f
 665 /*
 666 *
 667 *       Fun:   ssESBAlloc
 668 *
 669 *       Desc:  Allocates message and data blocks that point directly
 670 *              at a client-supplied buffer.
 671 *
 672 *       Ret:   non-NULL - ok
 673 *              NULL     - failure
 674 *
 675 *       Notes:
 676 *
 677 *       File:  ss_strm.c
 678 *
 679 */
 680 SsMblk *ssESBAlloc
 681 (
 682 uint8_t *base,                       /* client supplied data buffer */
 683 S32 size,                       /* size of data buffer */
 684 S32 pri,                        /* message priority */
 685 SsFrtn *fr_rtn                  /* free routine */
 686 )
 687 {
 688    SsMblk *bp;                  /* mblk for iteration */
 689    Size m;                      /* mblk + dblk */
 690    S16 r;                       /* return value */
 691
 692    UNUSED(pri);
 693
 694
 695 #if (ERRCLASS & ERRCLS_INT_PAR)
 696    if (base == NULLP  ||  fr_rtn == NULLP)
 697    {
 698       SSLOGERROR(ERRCLS_INT_PAR, ESS339, ERRZERO, "Null pointer");
 699       return (NULLP);
 700    }
 701 #endif
 702
 703
 704    /* allocate space for an mblock and a dblock */
 705    m = (sizeof(SsMblk) + sizeof(SsDblk));
 706 /* ss001.301: additions */
 707 #ifdef SS_HISTOGRAM_SUPPORT
 708    r = SAlloc(strmCfg.mdRegion, &m, 0, (Data **)&bp, __LINE__, (uint8_t*)__FILE__, ENTNC);
 709 #else
 710 #ifdef T2K_MEM_LEAK_DBG
 711    char* file = __FILE__;
 712    uint32_t line = __LINE__;
 713 #endif
 714    r = SAlloc(strmCfg.mdRegion, &m, 0, (Data **)&bp);
 715 #endif /* SS_HISTOGRAM_SUPPORT */
 716    if (r != ROK)
 717    {
 718 #if (ERRCLASS & ERRCLS_ADD_RES)
 719       SSLOGERROR(ERRCLS_ADD_RES, ESS340, (ErrVal) r, "SAlloc() failed");
 720 #endif
 721
 722       return (NULLP);
 723    }
 724
 725
 726    /* use the generic set-up-message function to initialize everything */
 727    SS_STRM_INITB(bp, (SsDblk *)(((uint8_t *)bp) + sizeof(SsMblk)),
 728                   base, size, fr_rtn);
 729
 730
 731    return (bp);
 732 } /* ssESBAlloc */
 733
 734 \f
 735 /*
 736 *
 737 *       Fun:   ssFreeB
 738 *
 739 *       Desc:  Deallocates the specified message block descriptor
 740 *              and frees the corresponding data block if the
 741 *              reference count is equal to 1. If not, the reference
 742 *              count is decremented.
 743 *
 744 *       Ret:   Void
 745 *
 746 *       Notes:
 747 *
 748 *       File:  ss_strm.c
 749 *
 750 */
 751 Void ssFreeB
 752 (
 753 SsMblk *mp                      /* message block */
 754 )
 755 {
 756    SsMblk *bp;                  /* mblk for iteration */
 757    Size size;                   /* mblk + dblk */
 758    /* ss028.103 - Addition of lock for mBuf reference count */
 759
 760 #ifdef T2K_MEM_LEAK_DBG
 761    char* file = __FILE__;
 762    uint32_t line = __LINE__;
 763 #endif
 764
 765 #if (ERRCLASS & ERRCLS_INT_PAR)
 766    if (mp == NULLP)
 767    {
 768       SSLOGERROR(ERRCLS_INT_PAR, ESS341, ERRZERO, "Null pointer");
 769       return;
 770    }
 771 #endif
 772
 773
 774    size = sizeof(SsMblk) + sizeof(SsDblk);
 775
 776
 777    /*  this mblock has already been freed, and still exists only
 778     *  because there is a reference to its dblock. it will be
 779     *  freed when the referring mblock is freed.
 780     */
 781
 782    if (mp->b_datap == NULLP)
 783    {
 784       return;
 785    }
 786
 787
 788    /* ?? this should never happen ?? */
 789    if (mp->b_datap->db_ref == 0)
 790    {
 791 #if (ERRCLASS & ERRCLS_DEBUG)
 792       SSLOGERROR(ERRCLS_DEBUG, ESS342, ERRZERO,
 793                   "Zero reference count in ssFreeB; logic failure");
 794 #endif
 795
 796 /* ss001.301: additions */
 797 #ifdef SS_HISTOGRAM_SUPPORT
 798       SFree(strmCfg.mdRegion, (Data *)mp, size, __LINE__, (uint8_t*)__FILE__, ENTNC);
 799 #else
 800 #ifdef T2K_MEM_LEAK_DBG
 801       SFree(strmCfg.mdRegion, (Data *)mp, size);
 802 #else
 803       SFree(strmCfg.mdRegion, (Data *)mp, size);
 804 #endif
 805 #endif /* SS_HISTOGRAM_SUPPORT */
 806       return;
 807    }
 808
 809    /* ss028.103 - Addition of lock for mBuf reference count */
 810         /* ss006.301 - use the mBufRefLock for the DFLT_REGION */
 811 #ifndef SS_DBUF_REFLOCK_DISABLE
 812    if(SLock(&mp->b_datap->dBufLock) != ROK)
 813    {
 814       SSLOGERROR(ERRCLS_DEBUG, ESS343, ERRZERO,
 815                      "Could not lock the mBuf Ref Lock");
 816       return;
 817    }
 818 #endif
 819
 820    /* decrement reference count of the dblock */
 821    mp->b_datap->db_ref--;
 822
 823         /* ss006.301 - use the mBufRefLock for the DFLT_REGION */
 824 #ifndef SS_DBUF_REFLOCK_DISABLE
 825    if ( SUnlock(&mp->b_datap->dBufLock) != ROK)
 826    {
 827 #if (ERRCLASS & ERRCLS_DEBUG)
 828       SSLOGERROR(ERRCLS_DEBUG, ESS344, ERRZERO,
 829                       "Could not give the Semaphore");
 830       return;
 831 #endif
 832    }
 833 #endif
 834
 835    /*  if we have no more references to this dblock, we can free
 836     *  the data buffer and the header.
 837     */
 838
 839    if (mp->b_datap->db_ref == 0)
 840    {
 841       /*  if there is a free routine, we call it for the data buffer;
 842        *  otherwise, we've allocated the data buffer and so we free it.
 843        */
 844 #ifndef SS_DBUF_REFLOCK_DISABLE
 845        SDestroyLock(&mp->b_datap->dBufLock);
 846 #endif
 847 /* ss008.301 */
 848 #ifdef SS_DBLK_FREE_RTN
 849       if (mp->b_datap->db_frtnp)
 850       {
 851          (*(mp->b_datap->db_frtnp->free_func))(mp->b_datap->db_frtnp->free_arg);
 852       }
 853       else
 854 #endif
 855       if (mp->b_datap->db_base != NULLP)
 856       {
 857 /* ss001.301: additions */
 858 #ifdef SS_HISTOGRAM_SUPPORT
 859          SFree(strmCfg.datRegion, mp->b_datap->db_base,
 860                   (Size)(mp->b_datap->db_lim - mp->b_datap->db_base),
 861                                                 __LINE__, (uint8_t*)__FILE__, ENTNC);
 862 #else
 863          SFree(strmCfg.datRegion, mp->b_datap->db_base,
 864                   (Size)(mp->b_datap->db_lim - mp->b_datap->db_base));
 865 #endif /* SS_HISTOGRAM_SUPPORT */
 866       }
 867
 868
 869       /*  if the dblock is in this header, we free this header
 870        *  and we're done. if the dblock is in another header,
 871        *  we have to free that header too.
 872        */
 873
 874       if (mp->b_datap != ((SsDblk *)(mp + sizeof(SsMblk))))
 875       {
 876          bp = (SsMblk *)(mp->b_datap - sizeof (SsMblk));
 877 /* ss001.301: additions */
 878 #ifdef SS_HISTOGRAM_SUPPORT
 879          SFree(strmCfg.mdRegion, (Data *)bp, size, __LINE__, (uint8_t*)__FILE__, ENTNC);
 880 #else
 881          SFree(strmCfg.mdRegion, (Data *)bp, size);
 882 #endif /* SS_HISTOGRAM_SUPPORT */
 883       }
 884
 885 /* ss001.301: additions */
 886 #ifdef SS_HISTOGRAM_SUPPORT
 887       SFree(strmCfg.mdRegion, (Data *)mp, size, __LINE__, (uint8_t*)__FILE__, ENTNC);
 888 #else
 889       SFree(strmCfg.mdRegion, (Data *)mp, size);
 890 #endif /* SS_HISTOGRAM_SUPPORT */
 891    }
 892    else
 893    {
 894       /*  reference count is non-zero; if it is this header's
 895        *  dblock, we don't free the header, we just mark the
 896        *  dblock pointer empty so we know about it. if it is
 897        *  another header's dblock, we can free this header.
 898        */
 899
 900       if (mp->b_datap == (SsDblk *)(mp + sizeof(SsMblk)))
 901       {
 902          mp->b_datap = NULLP;
 903       }
 904       else
 905       {
 906 /* ss001.301: additions */
 907 #ifdef SS_HISTOGRAM_SUPPORT
 908          SFree(strmCfg.mdRegion, (Data *)mp, size, __LINE__, (uint8_t*)__FILE__, ENTNC);
 909 #else
 910          SFree(strmCfg.mdRegion, (Data *)mp, size);
 911 #endif /* SS_HISTOGRAM_SUPPORT */
 912       }
 913    }
 914
 915    return;
 916 } /* ssFreeB */
 917
 918 \f
 919 /*
 920 *
 921 *       Fun:   ssFreeMsg
 922 *
 923 *       Desc:  Calls ssFreeB to free all message blocks and their
 924 *              corresponding data blocks for the specified
 925 *              message.
 926 *
 927 *       Ret:   Void
 928 *
 929 *       Notes:
 930 *
 931 *       File:  ss_strm.c
 932 *
 933 */
 934 Void ssFreeMsg
 935 (
 936 SsMblk *mp                      /* message block */
 937 )
 938 {
 939    SsMblk *bp;                  /* mblk for iteration */
 940
 941    /* free all the message blocks in the message */
 942    while (mp)
 943    {
 944       bp = mp;
 945       mp = mp->b_cont;
 946       ssFreeB(bp);
 947    }
 948
 949    return;
 950 } /* ssFreeMsg */
 951
 952 \f
 953 /*
 954 *
 955 *       Fun:   ssLinkB
 956 *
 957 *       Desc:  Puts the second specified message at the tail of
 958 *              the first specified message.
 959 *
 960 *       Ret:   Void
 961 *
 962 *       Notes:
 963 *
 964 *       File:  ss_strm.c
 965 *
 966 */
 967 Void ssLinkB
 968 (
 969 SsMblk *mp,                     /* first message block */
 970 SsMblk *bp                      /* second message block */
 971 )
 972 {
 973
 974 #if (ERRCLASS & ERRCLS_INT_PAR)
 975    if (mp == NULLP  ||  bp == NULLP)
 976    {
 977       SSLOGERROR(ERRCLS_INT_PAR, ESS345, ERRZERO, "Null pointer");
 978       return;
 979    }
 980 #endif
 981
 982
 983    /* run down to the end of the message */
 984    while (mp->b_cont)
 985    {
 986       mp = mp->b_cont;
 987    }
 988
 989
 990    /* link in the passed mblock */
 991    mp->b_cont = bp;
 992
 993    return;
 994 } /* ssLinkB */
 995
 996 \f
 997 /*
 998 *
 999 *       Fun:   ssMsgDSize
1000 *
1001 *       Desc:  Returns the number of bytes of data in the
1002 *              specified message.
1003 *
1004 *       Ret:   S32      - number of bytes
1005 *
1006 *       Notes:
1007 *
1008 *       File:  ss_strm.c
1009 *
1010 */
1011 S32 ssMsgDSize
1012 (
1013 SsMblk *mp                      /* message block */
1014 )
1015 {
1016    S32 n;                       /* temporary */
1017    S32 size;                    /* size of data */
1018
1019    /* for all blocks that are of type data, count the bytes */
1020    size = 0;
1021    while (mp)
1022    {
1023       if (mp->b_datap->db_type == SS_M_DATA)
1024       {
1025          n = mp->b_wptr - mp->b_rptr;
1026          if (n > 0)
1027          {
1028             size += n;
1029          }
1030       }
1031
1032       mp = mp->b_cont;
1033    }
1034
1035
1036    return (size);
1037 } /* ssMsgDSize */
1038
1039 \f
1040 /*
1041 *
1042 *       Fun:   ssPullupMsg
1043 *
1044 *       Desc:  Concatenates and aligns the first 'len' bytes
1045 *              of the specified message into a single, contiguous
1046 *              message block.
1047 *
1048 *       Ret:   1        - success
1049 *              0        - failure
1050 *
1051 *       Notes:
1052 *
1053 *       File:  ss_strm.c
1054 *
1055 */
1056 S32 ssPullupMsg
1057 (
1058 SsMblk *mp,                     /* message block */
1059 S32 len                         /* number of bytes to align */
1060 )
1061 {
1062    SsMblk *bp;                  /* mblk for iteration */
1063    SsMblk *newbp;               /* the new mblk */
1064    SsMblk *prev;                /* mblk of same type */
1065    uint8_t *base;                    /* for swapping data buffers */
1066    uint8_t *lim;                     /* for swapping data buffers */
1067    uint8_t *rptr;                    /* for swapping data buffers */
1068    uint8_t *wptr;                    /* for swapping data buffers */
1069         /* ss008.301 */
1070 #ifdef SS_DBLK_FREE_RTN
1071    SsFrtn *frtn;                /* for swapping data buffers */
1072 #endif
1073    S32 mLen;                    /* number of bytes in all blocks of same type */
1074    S32 m;                       /* temporary */
1075    S32 n;                       /* temporary */
1076    uint8_t type;                     /* message type */
1077
1078 #if (ERRCLASS & ERRCLS_INT_PAR)
1079    if (mp == NULLP)
1080    {
1081       SSLOGERROR(ERRCLS_INT_PAR, ESS346, ERRZERO, "Null pointer");
1082       return (0);
1083    }
1084
1085    if (len < -1)
1086    {
1087       SSLOGERROR(ERRCLS_INT_PAR, ESS347, len, "Invalid length");
1088       return (0);
1089    }
1090 #endif
1091
1092
1093    /* count the number of bytes in all blocks of the same type */
1094    bp = mp;
1095    mLen = 0;
1096    type = bp->b_datap->db_type;
1097    while (bp  &&  bp->b_datap->db_type == type)
1098    {
1099       n = bp->b_wptr - bp->b_rptr;
1100       if (n > 0)
1101       {
1102          mLen += n;
1103       }
1104
1105       bp = bp->b_cont;
1106    }
1107
1108    /* if -1 has been passed, we want to pull up all bytes */
1109    if (len == -1)
1110    {
1111       len = mLen;
1112    }
1113
1114    if (len == 0)
1115    {
1116       return (1);
1117    }
1118
1119
1120    /* do we have enough bytes to pull up? */
1121    if (len < 0  ||  len > mLen)
1122    {
1123       return (0);
1124    }
1125
1126
1127    /* allocate a new message of the required size */
1128    newbp = ssAllocB(len, 0);
1129    if (newbp == NULLP)
1130    {
1131       return (0);
1132    }
1133
1134    newbp->b_datap->db_type = mp->b_datap->db_type;
1135
1136
1137    /*  now we copy all the data in the blocks of the same type into
1138     *  this new message
1139     */
1140
1141    prev = NULLP;
1142    bp = mp;
1143    while (bp != NULLP)
1144    {
1145       /* if this buffer is of a different type, we just skip over it */
1146       if (bp->b_datap->db_type != newbp->b_datap->db_type)
1147       {
1148          prev = bp;
1149          bp = bp->b_cont;
1150          continue;
1151       }
1152
1153
1154       /* we have to copy this buffer */
1155       n = bp->b_wptr - bp->b_rptr;
1156       if (n > 0)
1157       {
1158          n = m = MIN(n, len);
1159          while (m > 0)
1160          {
1161             *newbp->b_wptr++ = *bp->b_rptr++;
1162             m--;
1163          }
1164
1165          len -= n;
1166       }
1167
1168
1169       /*  the buffer is copied, now--can we free it? if this the
1170        *  first buffer, we don't free it. also, if this buffer has
1171        *  something in it, we don't free it. otherwise, we link
1172        *  around this buffer, from the previous one to the next,
1173        *  and free this buffer.
1174        */
1175
1176       if (prev != NULLP  &&  bp->b_rptr == bp->b_wptr)
1177       {
1178          prev->b_cont = bp->b_cont;
1179          bp->b_cont = NULLP;
1180          ssFreeB(bp);
1181          bp = prev->b_cont;
1182       }
1183       else
1184       {
1185          prev = bp;
1186       }
1187    }
1188
1189
1190    /*  now we have to make the passed mblock point at the new data
1191     *  buffer we've just filled. then, we have to free the new
1192     *  mblock we created. also, we have to free the data buffer of
1193     *  the old mblock, we left it in there. we do this by basically
1194     *  swapping the data buffers of the passed mblock and the new
1195     *  mblock, and then freeing the new mblock.
1196     */
1197
1198    rptr = mp->b_rptr;
1199    wptr = mp->b_wptr;
1200    base = mp->b_datap->db_base;
1201    lim = mp->b_datap->db_lim;
1202 /* ss008.301 */
1203 #ifdef SS_DBLK_FREE_RTN
1204    frtn = mp->b_datap->db_frtnp;
1205 #endif
1206
1207    mp->b_rptr = newbp->b_rptr;
1208    mp->b_wptr = newbp->b_wptr;
1209    mp->b_datap->db_base = newbp->b_datap->db_base;
1210    mp->b_datap->db_lim = newbp->b_datap->db_lim;
1211 /* ss008.301 */
1212 #ifdef SS_DBLK_FREE_RTN
1213    mp->b_datap->db_frtnp = NULLP;
1214 #endif
1215
1216    newbp->b_rptr = rptr;
1217    newbp->b_wptr = wptr;
1218    newbp->b_datap->db_base = base;
1219    newbp->b_datap->db_lim = lim;
1220 /* ss008.301 */
1221 #ifdef SS_DBLK_FREE_RTN
1222    newbp->b_datap->db_frtnp = frtn;
1223 #endif
1224
1225    ssFreeB(newbp);
1226
1227
1228    return (1);
1229 } /* ssPullupMsg */
1230
1231 \f
1232 /*
1233 *
1234 *       Fun:   ssRmvB
1235 *
1236 *       Desc:  Removes the specified message block from the
1237 *              specified message and restores the linkage of
1238 *              the remaining blocks in the message.
1239 *
1240 *       Ret:   non-NULL - pointer to the head of the new message
1241 *              -1       - specified message block not found in message
1242 *              NULL     - failure
1243 *
1244 *       Notes: The block removed is not freed.
1245 *
1246 *       File:  ss_strm.c
1247 *
1248 */
1249 SsMblk *ssRmvB
1250 (
1251 SsMblk *mp,                     /* message */
1252 SsMblk *bp                      /* message block */
1253 )
1254 {
1255    SsMblk *rp;                  /* mblk that will be returned */
1256
1257 #if (ERRCLASS & ERRCLS_INT_PAR)
1258    if (mp == NULLP  ||  bp == NULLP)
1259    {
1260       SSLOGERROR(ERRCLS_INT_PAR, ESS348, ERRZERO, "Null pointer");
1261       return (NULLP);
1262    }
1263 #endif
1264
1265
1266    /* we will return rp */
1267    rp = mp;
1268
1269
1270    /* if the block to be removed is the first one, its easy */
1271    if (mp == bp)
1272    {
1273       rp = mp->b_cont;
1274    }
1275    /* otherwise we run through the message, hunting */
1276    else
1277    {
1278       for (; ;)
1279       {
1280          if (mp == NULLP)
1281          {
1282             return ((SsMblk *)-1);
1283          }
1284          else if (mp->b_cont == bp)
1285          {
1286             mp->b_cont = bp->b_cont;
1287             break;
1288          }
1289          else
1290          {
1291             mp = mp->b_cont;
1292          }
1293       }
1294    }
1295
1296
1297    /* we've removed bp from the message, clear its next pointer */
1298    bp->b_cont = NULLP;
1299
1300
1301    return (rp);
1302 } /* ssRmvB */
1303
1304 \f
1305 /*
1306 *
1307 *       Fun:   ssTestB
1308 *
1309 *       Desc:  Checks for the availability of a message buffer
1310 *              of the specified size without actually retrieving
1311 *              the buffer.
1312 *
1313 *       Ret:   1        - buffer is available
1314 *              0        - not available
1315 *
1316 *       Notes: Is currently a hack that allocates a message and
1317 *              frees it.
1318 *
1319 *       File:  ss_strm.c
1320 *
1321 */
1322 S32 ssTestB
1323 (
1324 S32 size,                       /* size required */
1325 uint32_t pri                         /* priority of the message buffer */
1326 )
1327 {
1328    SsMblk *bp;                  /* mblk for iteration */
1329
1330    bp = ssAllocB(size, pri);
1331    if (bp)
1332    {
1333       ssFreeB(bp);
1334       return (1);
1335    }
1336
1337
1338    return (0);
1339 } /* ssTestB */
1340
1341 \f
1342 /*
1343 *
1344 *       Fun:   ssUnlinkB
1345 *
1346 *       Desc:  Removes the first message block pointed at
1347 *              by the specified message and returns a pointer
1348 *              to the head of the resultant message.
1349 *
1350 *       Ret:   non-NULL - head of the new message
1351 *              NULL     - failure
1352 *
1353 *       Notes:
1354 *
1355 *       File:  ss_strm.c
1356 *
1357 */
1358 SsMblk *ssUnlinkB
1359 (
1360 SsMblk *mp                      /* message */
1361 )
1362 {
1363    SsMblk *bp;                  /* mblk for iteration */
1364
1365 #if (ERRCLASS & ERRCLS_INT_PAR)
1366    if (mp == NULLP)
1367    {
1368       SSLOGERROR(ERRCLS_INT_PAR, ESS349, ERRZERO, "Null pointer");
1369       return (NULLP);
1370    }
1371 #endif
1372
1373
1374    /* does this need a comment? ;) */
1375    bp = mp->b_cont;
1376    mp->b_cont = NULLP;
1377
1378
1379    return (bp);
1380 } /* ssUnlinkB */
1381
1382 /**********************************************************************
1383          End of file
1384  **********************************************************************/