src/mt/ss_queue.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 -- Queueing
  22
  23      Type:     C source file
  24
  25      Desc:     Source code for System Services queuing functions.
  26
  27      File:     ss_queue.c
  28
  29 *********************************************************************21*/
  30
  31
  32 \f
  33 /* header include files (.h) */
  34
  35 #include "envopt.h"        /* environment options */
  36 #include "envdep.h"        /* environment dependent */
  37 #include "envind.h"        /* environment independent */
  38
  39 #include "gen.h"           /* general layer */
  40 #include "ssi.h"           /* system services */
  41
  42 #include "ss_err.h"        /* errors */
  43 #include "ss_dep.h"        /* implementation-specific */
  44 #include "ss_queue.h"      /* queues */
  45 #include "ss_task.h"       /* tasking */
  46 #include "ss_strm.h"       /* STREAMS */
  47 #include "ss_msg.h"        /* messaging */
  48 #include "ss_mem.h"        /* memory management interface */
  49 #include "ss_gen.h"        /* general */
  50 #include "cm_mem.h"        /* memory management */
  51 /* ss040.103: addition */
  52 #include <errno.h>
  53
  54 /* header/extern include files (.x) */
  55
  56 #include "gen.x"           /* general layer */
  57 #include "ssi.x"           /* system services */
  58
  59 #include "ss_dep.x"        /* implementation-specific */
  60 #include "ss_queue.x"      /* queues */
  61 #include "ss_task.x"       /* tasking */
  62 #include "ss_timer.x"      /* timers */
  63 #include "ss_strm.x"       /* STREAMS */
  64 #include "ss_msg.x"        /* messaging */
  65 #include "ss_mem.x"        /* memory management interface */
  66 #include "ss_drvr.x"       /* driver tasks */
  67 #ifdef SS_LOCKLESS_MEMORY
  68 #include "cm_llist.x"
  69 #include "cm_hash.x"
  70 #include "cm_mem_wl.x"        /* common memory manager */
  71 #else
  72 #include "cm_mem.x"        /* common memory manager */
  73 #endif /* SS_LOCKLESS_MEMORY */
  74 #include "ss_gen.x"        /* general */
  75
  76
  77 \f
  78 /*
  79 *
  80 *       Fun:   SInitQueue
  81 *
  82 *       Desc:  This function initializes a queue.
  83 *
  84 *       Ret:   ROK      - ok
  85 *              RFAILED  - failed, general (optional)
  86 *
  87 *       Notes: no assumptions are made about the previous state
  88 *              of the queue.
  89 *
  90 *              queue size is set to zero.
  91 *
  92 *       File:  ss_queue.c
  93 *
  94 */
  95 #ifdef ANSI
  96 S16 SInitQueue
  97 (
  98 Queue *q               /* queue */
  99 )
 100 #else
 101 S16 SInitQueue(q)
 102 Queue *q;              /* queue */
 103 #endif
 104 {
 105
 106 #if (ERRCLASS & ERRCLS_INT_PAR)
 107    /* check queue pointer */
 108    if (q == NULLP)
 109    {
 110       SSLOGERROR(ERRCLS_INT_PAR, ESS266, ERRZERO, "Null Ptr");
 111       return RFAILED;
 112    }
 113 #endif
 114    q->head     = NULLP;
 115    q->tail     = NULLP;
 116    q->crntSize = 0;
 117
 118    return ROK;
 119
 120 } /* end of SInitQueue */
 121
 122 \f
 123 /*
 124 *
 125 *       Fun:   SFlushQueue
 126 *
 127 *       Desc:  This function will release all of the data or message
 128 *              buffers on the specified queue.
 129 *
 130 *       Ret:   ROK      - ok
 131 *              RFAILED  - failed, general (optional)
 132 *
 133 *       Notes: if queue is empty: no action is taken.
 134 *
 135 *              if queue is not empty: all buffers in queue are returned
 136 *              to memory. queue length is set to zero.
 137 *
 138 *              if dequeud buffer is a message buffer, all data buffers
 139 *              associated with the message buffer are returned to memory
 140 *
 141 *       File:  ss_queue.c
 142 *
 143 */
 144 #ifdef ANSI
 145 S16 SFlushQueue
 146 (
 147 Queue *q                    /* queue */
 148 )
 149 #else
 150 S16 SFlushQueue(q)
 151 Queue *q;                   /* queue */
 152 #endif
 153 {
 154    Buffer *tBuf;
 155    Buffer *mBuf;
 156    SsMsgInfo *minfo;
 157
 158 #ifdef T2K_MEM_LEAK_DBG
 159    char* file = __FILE__;
 160    uint32_t line = __LINE__;
 161 #endif
 162
 163
 164 #if (ERRCLASS & ERRCLS_INT_PAR)
 165    /* check queue */
 166    if (q == NULLP)
 167    {
 168       SSLOGERROR(ERRCLS_INT_PAR, ESS267, ERRZERO, "Null Q Ptr");
 169       return RFAILED;
 170    }
 171 #endif
 172
 173    tBuf = q->head;
 174    while (tBuf != NULLP)
 175    {
 176       mBuf = tBuf->b_next;
 177       if (tBuf->b_datap->db_type == SS_M_PROTO)
 178          SPutMsg(tBuf);
 179       else
 180       {
 181          minfo = (SsMsgInfo *) tBuf->b_rptr;
 182          SPutDBuf(minfo->region, minfo->pool, tBuf);
 183       }
 184       tBuf = mBuf;
 185    }
 186    q->crntSize = 0;
 187    q->head     = NULLP;
 188    q->tail     = NULLP;
 189
 190    return ROK;
 191
 192 } /* end of SFlushQueue */
 193
 194 \f
 195 /*
 196 *
 197 *       Fun:   SCatQueue
 198 *
 199 *       Desc:  This function will concatenate the two specified queues
 200 *              into one queue.
 201 *
 202 *       Ret:   ROK     - ok
 203 *              RFAILED - failed, general (optional)
 204 *
 205 *       Notes: if order equals Q1Q2: all buffers attached to queue 2 are
 206 *              moved to the end of queue 1. queue 2 is set to empty.
 207 *              queue 1 length is increased by length of queue 2. queue
 208 *              2 length is set to zero. return is ok.
 209 *
 210 *              if order equals Q2Q1: all buffers attached to queue 2 are
 211 *              moved to the front of queue 1. queue 2 is set to empty.
 212 *              queue 1 length is increased by length of queue 2. queue
 213 *              2 length is set to zero. return is ok.
 214 *
 215 *       File:  ss_queue.c
 216 *
 217 */
 218 #ifdef ANSI
 219 S16 SCatQueue
 220 (
 221 Queue *q1,                  /* queue 1 */
 222 Queue *q2,                  /* queue 2 */
 223 Order order                 /* order */
 224 )
 225 #else
 226 S16 SCatQueue(q1, q2, order)
 227 Queue *q1;                  /* queue 1 */
 228 Queue *q2;                  /* queue 2 */
 229 Order order;                /* order */
 230 #endif
 231 {
 232
 233 #if (ERRCLASS & ERRCLS_INT_PAR)
 234    if (q1 == NULLP)
 235    {
 236       SSLOGERROR(ERRCLS_INT_PAR, ESS268, ERRZERO, "Null Q1 Ptr");
 237       return RFAILED;
 238    }
 239
 240    if (q2 == NULLP)
 241    {
 242       SSLOGERROR(ERRCLS_INT_PAR, ESS269, ERRZERO, "Null Q2 Ptr");
 243       return RFAILED;
 244    }
 245
 246    if ((order != Q1Q2) && (order != Q2Q1))
 247    {
 248       SSLOGERROR(ERRCLS_INT_PAR, ESS270, ERRZERO, "Invalid queue order");
 249       return RFAILED;
 250    }
 251
 252    /* ss021.103 - Addition if Q1 is Q2 */
 253    if (q2 == q1)
 254    {
 255       SSLOGERROR(ERRCLS_INT_PAR, ESS271, ERRZERO, "Q1 == Q2");
 256       return RFAILED;
 257    }
 258
 259 #endif /* ERRCLASS */
 260
 261    if (q1->crntSize == 0)
 262    {
 263       q1->head       = q2->head;
 264       q1->tail       = q2->tail;
 265       q1->crntSize   = q2->crntSize;
 266
 267       q2->head       = NULLP;
 268       q2->tail       = NULLP;
 269       q2->crntSize   = 0;
 270
 271       return ROK;
 272    }
 273
 274    if (q2->crntSize == 0)
 275    {
 276       return ROK;
 277    }
 278
 279    switch (order)
 280    {
 281       case Q1Q2:
 282       {
 283          q1->tail->b_next = q2->head;
 284          q2->head->b_prev = q1->tail;
 285          q1->tail         = q2->tail;
 286
 287          break;
 288       }
 289
 290       case Q2Q1:
 291       {
 292          q2->tail->b_next = q1->head;
 293          q1->head->b_prev = q2->tail;
 294          q1->head         = q2->head;
 295
 296          break;
 297       }
 298       default:
 299          return RFAILED;
 300    }
 301
 302    q1->crntSize  += q2->crntSize;
 303
 304    q2->head       = NULLP;
 305    q2->tail       = NULLP;
 306    q2->crntSize   = 0;
 307
 308    return ROK;
 309
 310 } /* end of SCatQueue */
 311
 312
 313 \f
 314 /*
 315 *
 316 *       Fun:   SFndLenQueue
 317 *
 318 *       Desc:  This function determines the length of a queue.
 319 *
 320 *       Ret:   ROK      - ok
 321 *              RFAILED  - failed
 322 *
 323 *       Notes: length of queue is determined, queue is unchanged
 324 *              and length is returned via pointer to length.
 325 *
 326 *       File:  ss_queue.c
 327 *
 328 */
 329 #ifdef ANSI
 330 S16 SFndLenQueue
 331 (
 332 Queue *q,                   /* queue */
 333 QLen  *lngPtr               /* pointer to length */
 334 )
 335 #else
 336 S16 SFndLenQueue(q, lngPtr)
 337 Queue *q;                   /* queue */
 338 QLen  *lngPtr;              /* pointer to length */
 339 #endif
 340 {
 341
 342 #if (ERRCLASS & ERRCLS_INT_PAR)
 343    /* check queue */
 344    if (q == NULLP)
 345    {
 346       SSLOGERROR(ERRCLS_INT_PAR, ESS272, ERRZERO, "Null Q Ptr");
 347       return RFAILED;
 348    }
 349    /* check length */
 350    if (lngPtr == NULLP)
 351    {
 352       SSLOGERROR(ERRCLS_INT_PAR, ESS273, ERRZERO, "Null Q Len Ptr");
 353       return RFAILED;
 354    }
 355 #endif
 356
 357    *lngPtr = q->crntSize;
 358
 359    return ROK;
 360
 361 } /* end of SFndLenQueue */
 362
 363 \f
 364 /*
 365 *
 366 *       Fun:   SExamQueue
 367 *
 368 *       Desc:  This function examines the queue at the desired index.
 369 *
 370 *       Ret:   ROK      - ok
 371 *              ROKDNA   - ok, data not available
 372 *              RFAILED  - failed
 373 *
 374 *       Notes: index is 0 based and indicates location in queue.
 375 *
 376 *              if queue is empty: pointer to buffer is set to null and
 377 *              return is ok, data not available. queue length is unchanged.
 378 *
 379 *              if queue is not empty: pointer to buffer is set to indexed
 380 *              buffer in queue. return is ok. queue length is unchanged.
 381 *
 382 *       File:  ss_queue.c
 383 *
 384 */
 385 #ifdef ANSI
 386 S16 SExamQueue
 387 (
 388 Buffer **bufPtr,            /* pointer to buffer */
 389 Queue  *q,                  /* queue */
 390 QLen   idx                  /* index */
 391 )
 392 #else
 393 S16 SExamQueue(bufPtr, q, idx)
 394 Buffer **bufPtr;            /* pointer to buffer */
 395 Queue  *q;                  /* queue */
 396 QLen   idx;                 /* index */
 397 #endif
 398 {
 399    Buffer *tmpBuf;
 400    QLen   i;
 401
 402
 403 #if (ERRCLASS & ERRCLS_INT_PAR)
 404    /* check buffer pointer */
 405    if (bufPtr == NULLP)
 406    {
 407       SSLOGERROR(ERRCLS_INT_PAR, ESS274, ERRZERO, "Null Buf Ptr");
 408       return RFAILED;
 409    }
 410
 411    /* check index */
 412    if ((S32)idx < 0)
 413    {
 414       SSLOGERROR(ERRCLS_INT_PAR, ESS275, ERRZERO, "-ve index ");
 415       return RFAILED;
 416    }
 417
 418    /* check queue */
 419    if (q == NULLP)
 420    {
 421       SSLOGERROR(ERRCLS_INT_PAR, ESS276, ERRZERO, "Null Q Ptr");
 422       return RFAILED;
 423    }
 424 #endif /* ERRCLASS */
 425
 426    if (idx >= q->crntSize)
 427    {
 428       *bufPtr = NULLP;
 429       return (ROKDNA);
 430    }
 431
 432    if (idx == 0)
 433    {
 434       *bufPtr = q->head;
 435    }
 436    else  if (idx == q->crntSize -1)
 437    {
 438       *bufPtr = q->tail;
 439    }
 440    else
 441    {
 442       tmpBuf = q->head;
 443       for (i = 0; i < idx; i++)
 444       {
 445          tmpBuf = tmpBuf->b_next;
 446       }
 447       *bufPtr = tmpBuf;
 448    }
 449
 450    return ROK;
 451
 452 } /* end of SExamQueue */
 453
 454 \f
 455 /*
 456 *
 457 *       Fun:   SAddQueue
 458 *
 459 *       Desc:  This function inserts a bufer into the queue before
 460 *              the desired index.
 461 *
 462 *       Ret:   ROK     - ok
 463 *              RFAILED - failed
 464 *              ROKDNA  - failed - specified index not available
 465 *
 466 *       Notes: index is 0 based and indicates location in queue.
 467 *
 468 *              if queue is empty: buffer is placed in the queue.
 469 *              queue length is incremented.
 470 *
 471 *              if queue is not empty: if index is less than the queue length,
 472 *              buffer is inserted before the desired index;
 473 *              otherwise, buffer is placed behind all other buffers in queue.
 474 *              queue length is incremented.
 475 *
 476 *       File:  ss_queue.c
 477 *
 478 */
 479 #ifdef ANSI
 480 S16 SAddQueue
 481 (
 482 Buffer *mBuf,                /* buffer */
 483 Queue  *q,                   /* queue */
 484 QLen   idx                   /* index */
 485 )
 486 #else
 487 S16 SAddQueue(mBuf, q, idx)
 488 Buffer *mBuf;                /* buffer */
 489 Queue  *q;                   /* queue */
 490 QLen   idx;                  /* index */
 491 #endif
 492 {
 493    Buffer *tBuf;
 494    QLen   i;
 495
 496
 497 #if (ERRCLASS & ERRCLS_INT_PAR)
 498    /* check queue */
 499    if (q == NULLP)
 500    {
 501       SSLOGERROR(ERRCLS_INT_PAR, ESS277, ERRZERO, "Null Q Ptr");
 502       return RFAILED;
 503    }
 504
 505    if (mBuf == NULLP)
 506    {
 507       SSLOGERROR(ERRCLS_INT_PAR, ESS278, ERRZERO, "Null Buf Ptr");
 508       return RFAILED;
 509    }
 510
 511    if ((S32)idx < 0)
 512    {
 513       SSLOGERROR(ERRCLS_INT_PAR, ESS279, ERRZERO, "-ve index");
 514       return RFAILED;
 515    }
 516    /* ss021.103 - Addition to check buffer type and if duplicate message */
 517    if (mBuf->b_datap->db_type != SS_M_PROTO)
 518    {
 519       SSLOGERROR(ERRCLS_INT_PAR, ESS280, ERRZERO,
 520                  "Incorrect buffer type");
 521       return RFAILED;
 522    }
 523    tBuf = q->head;
 524    while (tBuf != (Buffer *)NULLP)
 525    {
 526       if (tBuf == mBuf)
 527       {
 528          SSLOGERROR(ERRCLS_INT_PAR, ESS281, ERRZERO, "Duplicate queued mBuf");
 529          return RFAILED;
 530       }
 531       tBuf = tBuf->b_next;
 532    }
 533 #endif /* ERRCLASS */
 534
 535    if (idx > q->crntSize)
 536    {
 537       SSLOGERROR(ERRCLS_DEBUG, ESS282, ERRZERO, "Invalid index");
 538       return (ROKDNA);
 539    }
 540    else if (q->crntSize == 0)
 541    {
 542       q->head = mBuf;
 543       q->tail = mBuf;
 544
 545       mBuf->b_next = NULLP;
 546       mBuf->b_prev = NULLP;
 547    }
 548    else if (idx == 0)
 549    {
 550       mBuf->b_next     = q->head;
 551       mBuf->b_prev     = NULLP;
 552       q->head->b_prev  = mBuf;
 553       q->head          = mBuf;
 554    }
 555    else if (idx == q->crntSize)
 556    {
 557       mBuf->b_prev    = q->tail;
 558       mBuf->b_next    = NULLP;
 559       q->tail->b_next = mBuf;
 560       q->tail         = mBuf;
 561    }
 562    else
 563    {
 564       tBuf = q->head;
 565       for (i = 0; i < idx; i++)
 566       {
 567          tBuf = tBuf->b_next;
 568       }
 569
 570       tBuf->b_prev->b_next = mBuf;
 571       mBuf->b_prev         = tBuf->b_prev;
 572       mBuf->b_next         = tBuf;
 573       tBuf->b_prev         = mBuf;
 574    }
 575    q->crntSize++;
 576    return ROK;
 577
 578 } /* end of SAddQueue */
 579
 580 \f
 581 /*
 582 *
 583 *       Fun:   SRemQueue
 584 *
 585 *       Desc:  This function removes a buffer from the queue at
 586 *              the desired index.
 587 *
 588 *       Ret:   ROK      - ok
 589 *              ROKDNA   - ok, data not available
 590 *              RFAILED  - failed
 591 *
 592 *       Notes: index is 0 based and indicates location in queue.
 593 *
 594 *              if queue is empty: pointer to buffer is set to null and
 595 *              return is ok, data not available. queue length is unchanged.
 596 *
 597 *              if queue is not empty: pointer to buffer is set to indexed
 598 *              buffer in queue. return is ok. queue length is decremented.
 599 *
 600 *       File:  ss_queue.c
 601 *
 602 */
 603 #ifdef ANSI
 604 S16 SRemQueue
 605 (
 606 Buffer **bufPtr,            /* pointer to buffer */
 607 Queue  *q,                  /* queue */
 608 QLen   idx                  /* index */
 609 )
 610 #else
 611 S16 SRemQueue(bufPtr, q, idx)
 612 Buffer **bufPtr;            /* pointer to buffer */
 613 Queue  *q;                  /* queue */
 614 QLen   idx;                 /* index */
 615 #endif
 616 {
 617    Buffer *tBuf;
 618    QLen   i;
 619
 620
 621 #if (ERRCLASS & ERRCLS_INT_PAR)
 622    /* check buffer pointer */
 623    if (bufPtr == NULLP)
 624    {
 625       SSLOGERROR(ERRCLS_INT_PAR, ESS283, ERRZERO, "Null Buf Ptr");
 626       return RFAILED;
 627    }
 628
 629    /* check queue */
 630    if (q == NULLP)
 631    {
 632       SSLOGERROR(ERRCLS_INT_PAR, ESS284, ERRZERO, "Null Q Ptr");
 633       return RFAILED;
 634    }
 635
 636    if ((S32)idx < 0)
 637    {
 638       SSLOGERROR(ERRCLS_INT_PAR, ESS285, ERRZERO, "-ve Index");
 639       return RFAILED;
 640    }
 641 #endif /* ERRCLASS */
 642
 643    if (idx >= q->crntSize)
 644    {
 645       *bufPtr = NULLP;
 646       return (ROKDNA);
 647    }
 648    if (idx == 0)
 649    {
 650       *bufPtr = q->head;
 651       if (q->crntSize == 1)
 652       {
 653          q->head = NULLP;
 654          q->tail = NULLP;
 655       }
 656       else
 657       {
 658          q->head         = q->head->b_next;
 659          q->head->b_prev = NULLP;
 660       }
 661    }
 662    else if (idx == q->crntSize -1)
 663    {
 664       *bufPtr = q->tail;
 665       q->tail = q->tail->b_prev;
 666       q->tail->b_next = NULLP;
 667    }
 668    else
 669    {
 670       tBuf = q->head;
 671
 672       for (i = 0; i < idx; i++)
 673       {
 674          tBuf = tBuf->b_next;
 675       }
 676       *bufPtr = tBuf;
 677
 678       tBuf->b_prev->b_next = tBuf->b_next;
 679       tBuf->b_next->b_prev = tBuf->b_prev;
 680    }
 681    q->crntSize--;
 682
 683    return ROK;
 684
 685 } /* end of SRemQueue */
 686
 687
 688 #ifndef SS_ENABLE_MACROS
 689
 690 \f
 691 /*
 692 *
 693 *       Fun:   SQueueFirst
 694 *
 695 *       Desc:  This function queues a data or message buffer to the
 696 *              front of the specified queue.
 697 *
 698 *       Ret:   ROK     - ok
 699 *              RFAILED - failed, general (optional)
 700 *
 701 *       Notes: if queue is empty: buffer is placed in the queue. queue
 702 *              length is incremented.
 703 *
 704 *              if queue is not empty: buffer is placed in front of all
 705 *              other buffers in queue. queue length is incremented.
 706 *
 707 *       File:  ss_queue.c
 708 *
 709 */
 710 #ifdef ANSI
 711 INLINE S16 SQueueFirst
 712 (
 713 Buffer *buf,                /* buffer */
 714 Queue *q                    /* queue */
 715 )
 716 #else
 717 INLINE S16 SQueueFirst(buf, q)
 718 Buffer *buf;                /* buffer */
 719 Queue *q;                   /* queue */
 720 #endif
 721 {
 722
 723    return (SAddQueue(buf, q, 0));
 724 } /* end of SQueueFirst */
 725
 726 \f
 727 /*
 728 *
 729 *       Fun:   SDequeueFirst
 730 *
 731 *       Desc:  This function dequeues a data or message buffer from
 732 *              the front of the specified queue.
 733 *
 734 *       Ret:   ROK      - ok
 735 *              ROKDNA   - ok, data not available
 736 *              RFAILED  - failed, general (optional)
 737 *
 738 *       Notes: if queue is empty: pointer to buffer is set to null and
 739 *              return is ok, data not available. queue length is unchanged.
 740 *
 741 *              if queue is not empty: pointer to buffer is set to first
 742 *              buffer in queue, first buffer in queue is removed and
 743 *              return is ok. queue length is decremented.
 744 *
 745 *       File:  ss_queue.c
 746 *
 747 */
 748 #ifdef ANSI
 749 INLINE S16 SDequeueFirst
 750 (
 751 Buffer **bufPtr,            /* pointer to buffer */
 752 Queue *q                    /* queue */
 753 )
 754 #else
 755 INLINE S16 SDequeueFirst(bufPtr, q)
 756 Buffer **bufPtr;            /* pointer to buffer */
 757 Queue *q;                   /* queue */
 758 #endif
 759 {
 760
 761    return (SRemQueue(bufPtr, q, 0));
 762 } /* end of SDequeueFirst */
 763
 764 \f
 765 /*
 766 *
 767 *       Fun:   SQueueLast
 768 *
 769 *       Desc:  This function queues a data or message buffer to the
 770 *              back of the specified queue.
 771 *
 772 *       Ret:   ROK      - ok
 773 *              RFAILED  - failed, general (optional)
 774 *
 775 *       Notes: if queue is empty: buffer is placed in the queue.
 776 *              queue length is incremented.
 777 *
 778 *              if queue is not empty: buffer is placed behind all
 779 *              other buffers in queue. queue length is incremented.
 780 *
 781 *       File:  ss_queue.c
 782 *
 783 */
 784 #ifdef ANSI
 785 S16 SQueueLast
 786 (
 787 Buffer *buf,                /* buffer */
 788 Queue *q                    /* queue */
 789 )
 790 #else
 791 S16 SQueueLast(buf, q)
 792 Buffer *buf;                /* buffer */
 793 Queue *q;                   /* queue */
 794 #endif
 795 {
 796
 797 #if (ERRCLASS & ERRCLS_INT_PAR)
 798    /* check queue */
 799    if (q == NULLP)
 800    {
 801       SSLOGERROR(ERRCLS_INT_PAR, ESS286, ERRZERO, "Null Q Ptr");
 802       return RFAILED;
 803    }
 804    /* check queue */
 805    if (buf == NULLP)
 806    {
 807       SSLOGERROR(ERRCLS_INT_PAR, ESS287, ERRZERO, "Null Buf Ptr");
 808       return RFAILED;
 809    }
 810 #endif
 811    return (SAddQueue(buf, (q), ((q)->crntSize)));
 812 }
 813
 814
 815 \f
 816 /*
 817 *
 818 *       Fun:   SDequeueLast
 819 *
 820 *       Desc:  This function dequeues a data or message buffer from the
 821 *              back of the specified queue.
 822 *
 823 *       Ret:   ROK     - ok
 824 *              ROKDNA  - ok, data not available
 825 *              RFAILED - failed, general (optional)
 826 *
 827 *       Notes: if queue is empty: pointer to buffer is set to null and
 828 *              return is ok, data not available. queue length is unchanged.
 829 *
 830 *              if queue is not empty: pointer to buffer is set to last
 831 *              buffer in queue, last buffer in queue is removed and
 832 *              return is ok. queue length is decremented.
 833 *
 834 *       File:  ss_queue.c
 835 *
 836 */
 837 #ifdef ANSI
 838 S16 SDequeueLast
 839 (
 840 Buffer **bufPtr,            /* pointer to buffer */
 841 Queue *q                    /* queue */
 842 )
 843 #else
 844 S16 SDequeueLast(bufPtr, q)
 845 Buffer **bufPtr;            /* pointer to buffer */
 846 Queue *q;                   /* queue */
 847 #endif
 848 {
 849    S16   ret;
 850
 851
 852 #if (ERRCLASS & ERRCLS_INT_PAR)
 853    /* check buffer pointer */
 854    if (!bufPtr)
 855    {
 856       SSLOGERROR(ERRCLS_INT_PAR, ESS288, ERRZERO, "Null Buf Ptr");
 857       return RFAILED;
 858    }
 859    /* check queue */
 860    if (!q)
 861    {
 862       SSLOGERROR(ERRCLS_INT_PAR, ESS289, ERRZERO, "Null Q Ptr");
 863       return RFAILED;
 864    }
 865 #endif
 866    if(q->crntSize > 0)
 867       ret = SRemQueue(bufPtr, q, q->crntSize-1);
 868    else
 869       ret = SRemQueue(bufPtr, q, q->crntSize);
 870
 871    return (ret);
 872 }
 873
 874 #endif /* SS_ENABLE_MACROS */
 875
 876 \f
 877 /*
 878 *
 879 *       Fun:   ssInitDmndQ
 880 *
 881 *       Desc:  This function initializes a Demand Queue
 882 *
 883 *       Ret:   ROK      - ok
 884 *              RFAILED  - failed
 885 *
 886 *       Notes:
 887 *
 888 *       File:  ss_queue.c
 889 *
 890 */
 891 #ifdef ANSI
 892 S16 ssInitDmndQ
 893 (
 894 SsDmndQ *dQueue                 /* Demand Queue */
 895 )
 896 #else
 897 S16 ssInitDmndQ(dQueue)
 898 SsDmndQ *dQueue;                /* Demand Queue */
 899 #endif
 900 {
 901    uint8_t  i;
 902    S16 ret;
 903
 904
 905 #if (ERRCLASS & ERRCLS_INT_PAR)
 906    if (dQueue == NULLP)
 907    {
 908       SSLOGERROR(ERRCLS_INT_PAR, ESS290, ERRZERO, "NULL DQ Pointer");
 909       return RFAILED;
 910    }
 911 #endif
 912
 913    for (i = 0; i < SS_MAX_NUM_DQ; i++)
 914    {
 915       dQueue->queue[i].head     = NULLP;
 916       dQueue->queue[i].tail     = NULLP;
 917       dQueue->queue[i].crntSize = 0;
 918    }
 919
 920 #ifndef TENB_RTLIN_CHANGES
 921    for (i = 0; i < SS_DQ_BIT_MASK_LEN; i++)
 922 #else
 923    for (i = 0; i < SS_MAX_NUM_DQ; i++)
 924 #endif
 925    {
 926 #ifndef TENB_RTLIN_CHANGES
 927       dQueue->bitMask[i] =  0;
 928 #endif
 929       /* ss039.103 : Replaced SInitLock with WTInitLock */
 930 #ifdef SS_WIN
 931       ret = WTInitLock(&dQueue->dmndQLock[i], SS_DMNDQ_LOCK);
 932 #else
 933       ret = SInitLock(&dQueue->dmndQLock[i], SS_DMNDQ_LOCK);
 934 #endif
 935       if (ret != ROK)
 936       {
 937 #if (ERRCLASS & ERRCLS_DEBUG)
 938          SSLOGERROR(ERRCLS_DEBUG, ESS291, (ErrVal)ret,
 939                                    "Failed to initialize lock");
 940 #endif
 941          return RFAILED;
 942       }
 943    }
 944
 945    /* initialize the semaphore */
 946    ret = ssInitSema(&dQueue->dmndQSema, 0);
 947    if (ret != ROK)
 948    {
 949 #ifndef TENB_RTLIN_CHANGES
 950       for (i = 0; i < SS_DQ_BIT_MASK_LEN; i++)
 951 #else
 952       for (i = 0; i < SS_MAX_NUM_DQ; i++)
 953 #endif
 954       {
 955          /* ss039.103 : Replaced SDestroyLock with WTDestroyLock */
 956 #ifdef SS_WIN
 957          WTDestroyLock(&dQueue->dmndQLock[i]);
 958 #else
 959          SDestroyLock(&dQueue->dmndQLock[i]);
 960 #endif
 961       }
 962 #if (ERRCLASS & ERRCLS_DEBUG)
 963       SSLOGERROR(ERRCLS_DEBUG, ESS292, (ErrVal)ret,
 964                                    "Failed to init semaphore");
 965 #endif
 966       return RFAILED;
 967    }
 968    return  (ROK);
 969
 970 } /* End of ssInitDmndQ */
 971
 972 \f
 973 /*
 974 *
 975 *       Fun:   ssDestroyDmndQ
 976 *
 977 *       Desc:  This function destroys a Demand Queue by releasing all the
 978 *              queued messages and detroying all the associated locks
 979 *
 980 *       Ret:   ROK      - ok
 981 *              RFAILED  - failed, general (optional)
 982 *
 983 *       Notes:
 984 *
 985 *       File:  ss_queue.c
 986 *
 987 */
 988 #ifdef ANSI
 989 S16 ssDestroyDmndQ
 990 (
 991 SsDmndQ *dQueue                        /* demand Queue */
 992 )
 993 #else
 994 S16 ssDestroyDmndQ(dQueue)
 995 SsDmndQ *dQueue;                       /* demand Queue */
 996 #endif
 997 {
 998    uint8_t     i;
 999    Buffer *tBuf;
1000    S16    ret;
1001
1002
1003 #if (ERRCLASS & ERRCLS_INT_PAR)
1004    if (dQueue == NULLP)
1005    {
1006       SSLOGERROR(ERRCLS_INT_PAR, ESS293, ERRZERO, "NULL DQ Pointer");
1007       return RFAILED;
1008    }
1009 #endif
1010
1011 #ifndef TENB_RTLIN_CHANGES
1012       for (i = 0; i < SS_DQ_BIT_MASK_LEN; i++)
1013 #else
1014       for (i = 0; i < SS_MAX_NUM_DQ; i++)
1015 #endif
1016    {
1017       /* ss039.103 : Replaced SDestroyLock with WTDestroyLock */
1018 #ifdef SS_WIN
1019       ret = WTDestroyLock(&dQueue->dmndQLock[i]);
1020 #else
1021       ret = SDestroyLock(&dQueue->dmndQLock[i]);
1022 #endif
1023       if (ret != ROK)
1024       {
1025 #if (ERRCLASS & ERRCLS_DEBUG)
1026          SSLOGERROR(ERRCLS_DEBUG, ESS294, (ErrVal)ret, "Failed to destroy lock");
1027 #endif
1028          return RFAILED;
1029       }
1030    }
1031    for (i = 0; i < SS_MAX_NUM_DQ; i++)
1032    {
1033       while (dQueue->queue[i].head != NULLP)
1034       {
1035          tBuf = dQueue->queue[i].head;
1036          dQueue->queue[i].head = dQueue->queue[i].head->b_next;
1037          SPutMsg(tBuf);
1038       }
1039    }
1040
1041 /* ss06.13:addition */
1042    if( ssDestroySema(&dQueue->dmndQSema) != ROK)
1043    {
1044       SSLOGERROR(ERRCLS_DEBUG, ESS295, ERRZERO,
1045                          "Could not delete the Semaphore");
1046       return RFAILED;
1047
1048    }
1049    return  (ROK);
1050
1051 } /* end of ssDestroyDmndQ */
1052
1053 \f
1054 /*
1055 *
1056 *       Fun:   ssDmndQPut
1057 *
1058 *       Desc:  This function adds a message to the head or tail of the
1059 *              priority queue specified. The priority specified is the
1060 *              destination Q index i.e
1061 *              ((dst_Tsk_pri * SS_MAX_MSG_PRI) + msg_pri)
1062 *
1063 *       Ret:   ROK      - ok
1064 *              RFAILED  - failed
1065 *
1066 *       Notes:
1067 *
1068 *       File:  ss_queue.c
1069 *
1070 */
1071 #ifdef ANSI
1072 S16 ssDmndQPut
1073 (
1074 SsDmndQ *dQueue,                       /* demand Queue */
1075 Buffer  *mBuf,                         /* message buffer */
1076 Prior   priority,                      /* priority */
1077 Order   order                          /* position */
1078 )
1079 #else
1080 S16 ssDmndQPut(dQueue, mBuf, priority, order)
1081 SsDmndQ *dQueue;                       /* demand Queue */
1082 Buffer  *mBuf;                         /* message buffer */
1083 Prior   priority;                      /* priority */
1084 Order   order;                         /* position */
1085 #endif
1086 {
1087 #ifndef TENB_RTLIN_CHANGES
1088    uint8_t     maskIndex;                   /* mask Index */
1089    uint8_t     bitPosition;                 /* bit position in index */
1090 #else
1091    uint8_t    qIndex;
1092 #endif
1093    Queue *queue;                       /* queue in demand queue */
1094    S16    ret;                         /* return value */
1095 #ifdef SS_PERF
1096    int    value;
1097    uint32_t    size;
1098 #endif
1099 #ifdef MSPD_MLOG_NEW
1100    uint32_t    t = MacGetTick();
1101 #endif
1102
1103
1104 #if (ERRCLASS & ERRCLS_INT_PAR)
1105    if (dQueue == NULLP)
1106    {
1107       SSLOGERROR(ERRCLS_INT_PAR, ESS296, ERRZERO, "NULL DQ Pointer");
1108       return RFAILED;
1109    }
1110
1111    if (mBuf == NULLP)
1112    {
1113       SSLOGERROR(ERRCLS_INT_PAR, ESS297, ERRZERO, "NULL mBuf Pointer");
1114       return RFAILED;
1115    }
1116
1117    if ((priority == PRIORNC) || (priority > SS_MAX_DQ_PRIOR))
1118    {
1119       SSLOGERROR(ERRCLS_INT_PAR, ESS298, ERRZERO, "invalid priority ");
1120       return RFAILED;
1121    }
1122
1123    if ((order != SS_DQ_FIRST) && (order != SS_DQ_LAST))
1124    {
1125       SSLOGERROR(ERRCLS_INT_PAR, ESS299, ERRZERO, "invalid order ");
1126       return RFAILED;
1127    }
1128 #endif
1129
1130 #ifndef TENB_RTLIN_CHANGES
1131    maskIndex   = priority >> 3;
1132    bitPosition = 7 - (priority % 8);
1133    queue       = &dQueue->queue[priority];
1134 #else
1135    qIndex      = priority;
1136    queue       = &dQueue->queue[qIndex];
1137 #endif
1138
1139    /* ss039.103 : Replaced SLock with WTLock */
1140 #ifdef SS_WIN
1141 #ifndef TENB_RTLIN_CHANGES
1142    ret = WTLock(&dQueue->dmndQLock[maskIndex]);
1143 #else
1144    ret = WTLock(&dQueue->dmndQLock[qIndex]);
1145 #endif
1146 #else
1147 #ifndef TENB_RTLIN_CHANGES
1148    ret = SLock(&dQueue->dmndQLock[maskIndex]);
1149 #else
1150    ret = SLock(&dQueue->dmndQLock[qIndex]);
1151 #endif
1152 #endif
1153    if (ret != ROK)
1154    {
1155 #if (ERRCLASS & ERRCLS_DEBUG)
1156       SSLOGERROR(ERRCLS_DEBUG, ESS300, (ErrVal)ret, "Failed to get lock");
1157 #endif
1158       return  (RFAILED);
1159    }
1160
1161    if (queue->crntSize == 0)
1162    {
1163       queue->head   = mBuf;
1164       queue->tail   = mBuf;
1165       mBuf->b_next  = NULLP;
1166       mBuf->b_prev  = NULLP;
1167
1168 #ifndef TENB_RTLIN_CHANGES
1169       /* Set the corresponding bit in bit mask */
1170       dQueue->bitMask[maskIndex] |= (1 << bitPosition);
1171 #endif
1172    }
1173    else
1174    {
1175       if (order == SS_DQ_LAST)
1176       {
1177          mBuf->b_prev        = queue->tail;
1178          mBuf->b_next        = NULLP;
1179          queue->tail->b_next = mBuf;
1180          queue->tail         = mBuf;
1181       }
1182       else
1183       {
1184          mBuf->b_next        = queue->head;
1185          mBuf->b_prev        = NULLP;
1186          queue->head->b_prev = mBuf;
1187          queue->head         = mBuf;
1188       }
1189    }
1190    queue->crntSize++;
1191 #ifdef SS_PERF
1192    size = queue->crntSize;
1193 #endif
1194
1195    /* ss039.103 : Replaced SUnlock with WTUnlock */
1196 #ifdef SS_WIN
1197 #ifndef TENB_RTLIN_CHANGES
1198    ret = WTUnlock(&dQueue->dmndQLock[maskIndex]);
1199 #else
1200    ret = WTUnlock(&dQueue->dmndQLock[qIndex]);
1201 #endif
1202 #else
1203 #ifndef TENB_RTLIN_CHANGES
1204    ret = SUnlock(&dQueue->dmndQLock[maskIndex]);
1205 #else
1206    ret = SUnlock(&dQueue->dmndQLock[qIndex]);
1207 #endif
1208 #endif
1209    if (ret != ROK)
1210    {
1211 #if (ERRCLASS & ERRCLS_DEBUG)
1212       SSLOGERROR(ERRCLS_DEBUG, ESS301, (ErrVal)ret, "Failed to release lock");
1213 #endif
1214       /* ss035.103 */
1215       if (order == SS_DQ_LAST)
1216       {
1217          SDequeueLast(&mBuf, queue);
1218       }
1219       else
1220       {
1221          SDequeueFirst(&mBuf, queue);
1222       }
1223       return  (RFAILED);
1224    }
1225
1226    /* increment the counting semaphore */
1227    /* ss006.13: addition */
1228
1229 /* ss037.103 for Performance enhancement : this is to ensure that semaphore is posted every time the first message is posted to the queue so that permanent tick is picked */
1230 #ifdef SS_PERF
1231   if (size > 1)
1232   {
1233      sem_getvalue(&dQueue->dmndQSema, &value);
1234      if (value > 0)
1235            return ROK;
1236   }
1237 #endif
1238    if (ssPostSema(&dQueue->dmndQSema) != ROK)
1239    {
1240 #if (ERRCLASS & ERRCLS_DEBUG)
1241        SSLOGERROR(ERRCLS_DEBUG, ESS302, ERRZERO,
1242                          "Could not unlock the Semaphore");
1243        /* ss035.103 */
1244        if (order == SS_DQ_LAST)
1245        {
1246           SDequeueLast(&mBuf, queue);
1247        }
1248        else
1249        {
1250           SDequeueFirst(&mBuf, queue);
1251        }
1252        return RFAILED;
1253 #endif
1254    }
1255    return ROK;
1256
1257 } /* End of ssDmndQPut */
1258
1259 \f
1260 /*
1261 *
1262 *       Fun:   ssDmndQWait
1263 *
1264 *       Desc:  This function removes a message from head or tail of the
1265 *              highest non-empty priority queue message.
1266 *
1267 *       Ret:   ROK      - ok
1268 *              RFAILED  - failed
1269 *              ROKDNA   - ok, no data available in queue
1270 *
1271 *       Notes:  This is a blocking call
1272 *
1273 *       File:  ss_queue.c
1274 *
1275 */
1276 #ifdef ANSI
1277 S16 ssDmndQWait
1278 (
1279 SsDmndQ *dQueue                          /* demand queue */
1280 )
1281 #else
1282 S16 ssDmndQWait(dQueue)
1283 SsDmndQ *dQueue;                          /* demand queue */
1284 #endif
1285 {
1286    S16   ret;
1287
1288
1289 #if (ERRCLASS & ERRCLS_INT_PAR)
1290    if (dQueue == NULLP)
1291    {
1292       SSLOGERROR(ERRCLS_INT_PAR, ESS303, ERRZERO, "NULL DQ Pointer");
1293       return RFAILED;
1294    }
1295
1296 #endif
1297
1298    /* ss040.103 updating for possible non-fatal retur from sem_wait */
1299    while ((ret = ssWaitSema(&dQueue->dmndQSema) != ROK) && (errno == EINTR))
1300       continue;
1301    if (ret != ROK)
1302    {
1303 #if (ERRCLASS & ERRCLS_DEBUG)
1304       SSLOGERROR(ERRCLS_DEBUG, ESS306, (ErrVal)ret, "Failed to get semaphore");
1305 #endif
1306       return  (RFAILED);
1307    }
1308
1309    return  (ROK);
1310 } /* End of ssDmndQWait */
1311
1312
1313 \f
1314 /*
1315 *
1316 *       Fun:   ssDmndQGet
1317 *
1318 *       Desc:  This function removes a message from head or tail of the
1319 *              highest non-empty priority queue message.
1320 *
1321 *       Ret:   ROK      - ok
1322 *              RFAILED  - failed
1323 *              ROKDNA   - ok, no data available in queue
1324 *
1325 *       Notes:  This is a blocking call
1326 *
1327 *       File:  ss_queue.c
1328 *
1329 */
1330 #ifdef ANSI
1331 S16 ssDmndQGet
1332 (
1333 SsDmndQ *dQueue,                          /* demand queue */
1334 Buffer  **mBuf,                           /* message buffer */
1335 Order   order                             /* position */
1336 )
1337 #else
1338 S16 ssDmndQGet(dQueue, mBuf, order)
1339 SsDmndQ *dQueue;                          /* demand queue */
1340 Buffer  **mBuf;                           /* message buffer */
1341 Order   order;                            /* position */
1342 #endif
1343 {
1344    Queue *queue;
1345    S16   ret;
1346    S16   i;
1347 #ifndef TENB_RTLIN_CHANGES
1348    uint8_t    bitPosition;
1349    uint8_t    qIndex;
1350 #endif
1351
1352
1353 #if (ERRCLASS & ERRCLS_INT_PAR)
1354    if (mBuf == NULLP)
1355    {
1356       SSLOGERROR(ERRCLS_INT_PAR, ESS304, ERRZERO, "NULL mBuf Pointer");
1357       return RFAILED;
1358    }
1359
1360    if ((order != SS_DQ_FIRST) && (order != SS_DQ_LAST))
1361    {
1362       SSLOGERROR(ERRCLS_INT_PAR, ESS305, ERRZERO, "invalid order ");
1363       return RFAILED;
1364    }
1365 #endif
1366
1367 #ifndef TENB_RTLIN_CHANGES
1368    for (i = 0; i < SS_DQ_BIT_MASK_LEN; i++)
1369    {
1370       /* ss039.103 : Replaced SLock with WTLock */
1371 #ifdef SS_WIN
1372       ret = WTLock(&dQueue->dmndQLock[i]);
1373 #else
1374       ret = SLock(&dQueue->dmndQLock[i]);
1375 #endif
1376       if (ret != ROK)
1377       {
1378 #if (ERRCLASS & ERRCLS_DEBUG)
1379          SSLOGERROR(ERRCLS_DEBUG, ESS307, (ErrVal)ret, "Failed to get lock");
1380 #endif
1381          return  (RFAILED);
1382       }
1383
1384       bitPosition = osCp.dmndQLookupTbl[dQueue->bitMask[i]];
1385       if (bitPosition != 255)
1386          break;
1387
1388       /* ss039.103 : Replaced SUnlock with WTUnlock */
1389 #ifdef SS_WIN
1390       ret = WTUnlock(&dQueue->dmndQLock[i]);
1391 #else
1392       ret = SUnlock(&dQueue->dmndQLock[i]);
1393 #endif
1394       if (ret != ROK)
1395       {
1396 #if (ERRCLASS & ERRCLS_DEBUG)
1397          SSLOGERROR(ERRCLS_DEBUG, ESS308, ret, "Failed to release lock");
1398 #endif
1399          return  (RFAILED);
1400       }
1401    }
1402    if (i >= SS_DQ_BIT_MASK_LEN)
1403    {
1404       /* Demand Queue is empty */
1405       *mBuf = NULLP;
1406       return  (ROKDNA);
1407    }
1408
1409    qIndex = (i * 8) +  (7 - bitPosition);
1410    queue = &dQueue->queue[qIndex];
1411
1412 #else
1413    for (i = 0; i < SS_MAX_NUM_DQ; i++)
1414    {
1415       queue = &dQueue->queue[i];
1416       if (queue->crntSize)
1417          break;
1418    }
1419
1420    if (i >= SS_MAX_NUM_DQ)
1421    {
1422       /* Demand Queue is empty */
1423       *mBuf = NULLP;
1424       return  (ROKDNA);
1425    }
1426
1427    /* ss039.103 : Replaced SLock with WTLock */
1428 #ifdef SS_WIN
1429    ret = WTLock(&dQueue->dmndQLock[i]);
1430 #else
1431    ret = SLock(&dQueue->dmndQLock[i]);
1432 #endif
1433    if (ret != ROK)
1434    {
1435 #if (ERRCLASS & ERRCLS_DEBUG)
1436       SSLOGERROR(ERRCLS_DEBUG, ESS307, (ErrVal)ret, "Failed to get lock");
1437 #endif
1438       return  (RFAILED);
1439    }
1440
1441 #endif
1442 /* ss037.103 For performance enhancement replace the check sequence with simple
1443 setting the crntSize to 0 and removing the message */
1444 #ifndef SS_PERF
1445    if (queue->crntSize == 1)
1446    {
1447       *mBuf = queue->head;
1448       queue->head = NULLP;
1449       queue->tail = NULLP;
1450
1451       /* Reset the corresponding bit in bit mask */
1452       dQueue->bitMask[i] &= (~( 1 << (bitPosition)));
1453    }
1454    else
1455    {
1456       if (order == SS_DQ_FIRST)
1457       {
1458          *mBuf = queue->head;
1459          queue->head = queue->head->b_next;
1460          queue->head->b_prev = NULLP;
1461       }
1462       else
1463       {
1464          *mBuf = queue->tail;
1465          queue->tail = queue->tail->b_prev;
1466          queue->tail->b_next = NULLP;
1467       }
1468    }
1469    queue->crntSize--;
1470 #else
1471    queue->crntSize = 0;
1472    *mBuf = queue->head;
1473    queue->head = NULLP;
1474    queue->tail = NULLP;
1475
1476 #endif
1477
1478    /* ss039.103 : Replaced SUnlock with WTUnlock */
1479 #ifdef SS_WIN
1480    ret = WTUnlock(&dQueue->dmndQLock[i]);
1481 #else
1482    ret = SUnlock(&dQueue->dmndQLock[i]);
1483 #endif
1484    if (ret != ROK)
1485    {
1486 #if (ERRCLASS & ERRCLS_DEBUG)
1487       SSLOGERROR(ERRCLS_DEBUG, ESS309, (ErrVal)ret, "Failed to release lock");
1488 #endif
1489       return  (RFAILED);
1490    }
1491
1492    return  (ROK);
1493
1494 } /* End of ssDmndQGet */
1495
1496 \f
1497 /*
1498 *
1499 *       Fun:   ssFndLenDmndQ
1500 *
1501 *       Desc:  This function returns the number of messages in a queue
1502 *              If priority is specified, length of the associated Q is
1503 *              returned otherwise total length of all Qs is returned.
1504 *
1505 *       Ret:   ROK      - ok
1506 *              RFAILED  - failed
1507 *
1508 *       Notes:
1509 *
1510 *       File:  ss_queue.c
1511 *
1512 */
1513 #ifdef ANSI
1514 S16 ssFndLenDmndQ
1515 (
1516 SsDmndQ *dQueue,                               /* demand queue */
1517 Prior   priority,                              /* priority */
1518 QLen    *len                                   /* queue length */
1519 )
1520 #else
1521 S16 ssFndLenDmndQ(dQueue, priority, len)
1522 SsDmndQ *dQueue;                               /* demand queue */
1523 Prior   priority;                              /* priority */
1524 QLen    *len;                                  /* queue length */
1525 #endif
1526 {
1527
1528    S16  ret;                                   /* return value */
1529    uint8_t   i;
1530
1531
1532 #if (ERRCLASS & ERRCLS_INT_PAR)
1533    if ((dQueue == NULLP) || (len == NULLP))
1534    {
1535       SSLOGERROR(ERRCLS_INT_PAR, ESS310, ERRZERO, "NULL Pointer");
1536       return RFAILED;
1537    }
1538 #endif
1539
1540    *len = 0;
1541    if (priority != PRIORNC)
1542    {
1543       i = priority >> 3;
1544       /* ss039.103 : Replaced SLock with WTLock */
1545 #ifdef SS_WIN
1546       ret = WTLock(&dQueue->dmndQLock[i]);
1547 #else
1548       ret = SLock(&dQueue->dmndQLock[i]);
1549 #endif
1550       if (ret != ROK)
1551       {
1552 #if (ERRCLASS & ERRCLS_DEBUG)
1553          SSLOGERROR(ERRCLS_DEBUG, ESS311, (ErrVal)ret, "Failed to get lock");
1554 #endif
1555          return  (RFAILED);
1556       }
1557
1558       *len = dQueue->queue[priority].crntSize;
1559
1560       /* ss039.103 : Replaced SUnlock with WTUnlock */
1561 #ifdef SS_WIN
1562       ret = WTUnlock(&dQueue->dmndQLock[i]);
1563 #else
1564       ret = SUnlock(&dQueue->dmndQLock[i]);
1565 #endif
1566       if (ret != ROK)
1567       {
1568 #if (ERRCLASS & ERRCLS_DEBUG)
1569          SSLOGERROR(ERRCLS_DEBUG, ESS312, (ErrVal)ret,  \
1570                                          "Failed to release lock");
1571 #endif
1572          return  (RFAILED);
1573       }
1574    }
1575    else
1576    {
1577 #ifndef TENB_RTLIN_CHANGES
1578       for (i = 0; i < SS_DQ_BIT_MASK_LEN; i++)
1579 #else
1580       for (i = 0; i < SS_MAX_NUM_DQ; i++)
1581 #endif
1582       {
1583          /* ss039.103 : Replaced SLock with WTLock */
1584 #ifdef SS_WIN
1585          ret = WTLock(&dQueue->dmndQLock[i]);
1586 #else
1587          ret = SLock(&dQueue->dmndQLock[i]);
1588 #endif
1589          if (ret != ROK)
1590          {
1591 #if (ERRCLASS & ERRCLS_DEBUG)
1592             SSLOGERROR(ERRCLS_DEBUG, ESS313, (ErrVal)ret, "Failed to get lock");
1593 #endif
1594             /* Release all the locks aquired */
1595             while (i > 0)
1596             {
1597
1598 /* ss006.13: addition */
1599                 /* ss039.103 : Replaced SUnlock with WTUnlock */
1600 #ifdef SS_WIN
1601                 if( WTUnlock(&dQueue->dmndQLock[i-1]) != ROK)
1602 #else
1603                 if( SUnlock(&dQueue->dmndQLock[i-1]) != ROK)
1604 #endif
1605                 {
1606 #if (ERRCLASS & ERRCLS_DEBUG)
1607                    SSLOGERROR(ERRCLS_DEBUG, ESS314, ERRZERO,
1608                          "Could not give the Semaphore");
1609                    return RFAILED;
1610 #endif
1611                 }
1612
1613                i--;
1614             }
1615
1616             return  (RFAILED);
1617          }
1618       }
1619
1620       for (i = 0; i  < SS_MAX_NUM_DQ; i++)
1621          *len  += dQueue->queue[i].crntSize;
1622
1623 #ifndef TENB_RTLIN_CHANGES
1624       for (i = 0; i < SS_DQ_BIT_MASK_LEN; i++)
1625 #else
1626       for ( i = 0; i < SS_MAX_NUM_DQ; i++)
1627 #endif
1628       {
1629          /* ss039.103 : Replaced SUnlock with WTUnlock */
1630 #ifdef SS_WIN
1631          ret = WTUnlock(&dQueue->dmndQLock[i]);
1632 #else
1633          ret = SUnlock(&dQueue->dmndQLock[i]);
1634 #endif
1635          if (ret != ROK)
1636          {
1637 #if (ERRCLASS & ERRCLS_DEBUG)
1638             SSLOGERROR(ERRCLS_DEBUG, ESS315, (ErrVal)ret, "Failed to get lock");
1639 #endif
1640             return  (RFAILED);
1641          }
1642       }
1643    }
1644    return ROK;
1645
1646 } /* End of ssFndLenDmndQ */
1647
1648 /**********************************************************************
1649          End of file
1650 **********************************************************************/