home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Professional Developers Kit 1992 November / Disc01 / Disc01.mdf / runnable / mmos2 / mmtoolkt / samples / fssht / fsshcrea.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-05-06  |  11.0 KB  |  258 lines
  1. /****************************************************************************/
  2. /*                                                                          */
  3. /*                    Copyright (c) IBM Corporation 1992                    */
  4. /*                           All Rights Reserved                            */
  5. /*                                                                          */
  6. /* SOURCE FILE NAME: FSSHCREA.C                                             */
  7. /*                                                                          */
  8. /* DESCRIPTIVE NAME:  Stream Handler Create stream routine for file system  */
  9. /*                    stream handler                                        */
  10. /*                                                                          */
  11. /* FUNCTION: This function is creates a stream instance.                    */
  12. /*                                                                          */
  13. /* ENTRY POINTS: ShcCreate                                                  */
  14. /*                                                                          */
  15. /*************************** END OF SPECIFICATIONS **************************/
  16. #define  INCL_NOPMAPI                  /* no PM include files required */
  17. #define  INCL_DOSSEMAPHORES
  18. #define  INCL_DOSPROCESS
  19. #include <os2.h>
  20. #include <os2me.h>
  21. #include <hhpheap.h>
  22. #include <shi.h>
  23.  
  24. /************************** START OF SPECIFICATIONS *************************/
  25. /*                                                                          */
  26. /* SUBROUTINE NAME: ShcCreate                                               */
  27. /*                                                                          */
  28. /* DESCRIPTIVE NAME: Stream Handler Command Create stream routine           */
  29. /*                                                                          */
  30. /* FUNCTION: This routine creates a stream instance of the datatype and     */
  31. /*   subtype passed.                                                        */
  32. /*                                                                          */
  33. /* NOTES:                                                                   */
  34. /*                                                                          */
  35. /* ENTRY POINT: ShcCreate                                                   */
  36. /*   LINKAGE:   CALL NEAR (0:32)                                            */
  37. /*                                                                          */
  38. /* INPUT: Pointer to shc create parameter block (PARM_CREATE) containing:   */
  39. /*   ULONG   ulFunction  Handler command function SHC_CREATE                */
  40. /*   HID     hid         handler ID                                         */
  41. /*   HSTREAM hstream     handle of stream instance                          */
  42. /*   ULONG   ulFlag      Seek flag with following possible Flags:           */
  43. /*                         SPI_SEEK_ABSOLUTE                                */
  44. /*                                                                          */
  45. /* EXIT-NORMAL: NO_ERROR (0)                                                */
  46. /*                                                                          */
  47. /* EXIT-ERROR:                                                              */
  48. /*   ERROR_INVALID_SPCBKEY                                                  */
  49. /*   ERROR_ALLOC_RESOURCES                                                  */
  50. /*   Errors from the external routines:                                     */
  51. /*     DosRequestMutexSem                                                   */
  52. /*     DosCreateThread                                                      */
  53. /*                                                                          */
  54. /* SIDE EFFECTS:                                                            */
  55. /*   Stream Instance Block allocated and added to active list.              */
  56. /*   Thread created suspended to perform I/O (read/write).                  */
  57. /*                                                                          */
  58. /* EXTERNAL REFERENCES:                                                     */
  59. /*   ROUTINES:                                                              */
  60. /*     ShFindEspcb                                                          */
  61. /*     HhpAllocMem                                                          */
  62. /*     DosRequestMutexSem                                                   */
  63. /*     DosCreateThread                                                      */
  64. /*     DosReleaseMutexSem                                                   */
  65. /*     DosSetPriority                                                       */
  66. /*     DosResumeThread                                                      */
  67. /*     DosWaitThread                                                        */
  68. /*     HhpFreeMem                                                           */
  69. /*     HhpGetPID                                                            */
  70. /*                                                                          */
  71. /*   DATA STRUCTURES:                                                       */
  72. /*     hmtxGlobalData                                                       */
  73. /*     pESPCB_ListHead                                                      */
  74. /*     hHeap                                                                */
  75. /*     TgtHandlerID                                                         */
  76. /*************************** END OF SPECIFICATIONS **************************/
  77.  
  78. RC ShcCreate(pcrparm)
  79. PPARM_CREATE pcrparm;
  80.  
  81. { /* Start of ShcCreate */
  82.  
  83. RC      rc = NO_ERROR;                   // local return code
  84. PSIB    psib = NULL;                     // Stream instance block
  85. PESPCB  pEspcb;                          // -> to espcb for spcb key passed
  86. int     notfound = TRUE;                 // loop control
  87. BOOL    bIOThreadCreated = FALSE;        // local var for error processing
  88. BOOL    bHevStopCreated = FALSE;
  89. BOOL    bHevCmdSyncCreated = FALSE;
  90.  
  91.   /*
  92.    * locate the correct spcb
  93.    * allocate sib
  94.    * create a thread to read or write
  95.    * set thread priority
  96.    * call smhinit
  97.    * add sib to list
  98.    */
  99.   /*
  100.    * Locate the spcb; if not found use the generic spcb
  101.    * Note: there is not checking for if this espcb can support
  102.    * being the requested source or target.
  103.    */
  104.  
  105.   if (!(rc = DosRequestMutexSem(hmtxGlobalData, SEM_INDEFINITE_WAIT)))
  106.     { /* we have the mutex sem */
  107.  
  108.       pEspcb = ShFindEspcb(pcrparm->spcbkey);
  109.       //
  110.       // If espcb not found then get the last generic spcb installed and use it.
  111.       //
  112.       if (!pEspcb)
  113.         { /* Get Generic spcb */
  114.  
  115.           rc = ERROR_INVALID_SPCBKEY;
  116.           pEspcb = pESPCB_ListHead;
  117.           while (pEspcb && notfound)
  118.             { /* Loop thru espcbs */
  119.               if (pEspcb->spcb.spcbkey.ulDataType == DATATYPE_GENERIC)
  120.                 {
  121.                   notfound = FALSE;
  122.                   rc = NO_ERROR;
  123.                 }
  124.               else
  125.                 {
  126.                   pEspcb = pEspcb->pnxtESPCB;
  127.                 }
  128.             } /* Loop thru espcbs */
  129.         } /* Get Generic spcb */
  130.       //
  131.       // If we have an espcb alloc a stream instance block and copy the espcb
  132.       //
  133.       if (!rc)
  134.         {
  135.           /*
  136.            * Allocate a SIB and copy ESPCB
  137.            */
  138.           psib = (PSIB)HhpAllocMem(hHeap, sizeof(SIB));
  139.           if (psib)
  140.             { /* SIB allocated */
  141.  
  142.               psib->espcb = *pEspcb;              // copy entire structure
  143.               // copy over data subtype.  SSM needs this particular field even if
  144.               //  it is generic.  In most cases it is already the same.
  145.               psib->espcb.spcb.spcbkey.ulDataSubType = pcrparm->spcbkey.ulDataSubType;
  146.  
  147.             } /* SIB allocated */
  148.           else
  149.             { /* Error allocating sib */
  150.  
  151.               rc = ERROR_ALLOC_RESOURCES;
  152.  
  153.             } /* Error allocating sib */
  154.         }
  155.       DosReleaseMutexSem(hmtxGlobalData);
  156.     } /* we have the mutex sem */
  157.  
  158.   if (!rc)
  159.     { /* we have sib and espcb */
  160.  
  161.       //
  162.       // Now create the semaphores for starting and stopping the IO thread
  163.       // and for command synchronization.
  164.       //
  165.       rc = DosCreateEventSem(NULL, &psib->hevStop, 0L, FALSE);
  166.       if (!rc)
  167.         {
  168.           bHevStopCreated = TRUE;
  169.           rc = DosCreateEventSem(NULL, &psib->hevCmdSync, 0L, FALSE);
  170.           if (!rc)
  171.             bHevCmdSyncCreated = TRUE;
  172.         }
  173.  
  174.       if (!rc)
  175.         {
  176.           psib->HandlerID = pcrparm->hid;
  177.           psib->hStream = pcrparm->hstream;
  178.           psib->ulActionFlags = 0;
  179.           psib->ProcessID = HhpGetPID();
  180.           pcrparm->pspcb = &psib->espcb.spcb;           // return spcb address
  181.           psib->ulStatus = SIB_INITIALIZED;
  182.           /*
  183.            * Create the read/write thread and set it to Time Critical priority
  184.            */
  185.           if (pcrparm->hid == TgtHandlerID)
  186.             {
  187.               rc = DosCreateThread(&psib->ThreadID,
  188.                                    (PFNTHREAD)ShWriteRtn,
  189.                                    (ULONG)psib,
  190.                                    0L,
  191.                                    STACKSIZE);
  192.             }
  193.           else
  194.             {
  195.               rc = DosCreateThread(&psib->ThreadID,
  196.                                    (PFNTHREAD)ShReadRtn,
  197.                                    (ULONG)psib,
  198.                                    0L,
  199.                                    STACKSIZE);
  200.             }
  201.         }
  202.       if (!rc)
  203.         { /* IO Thread created */
  204.  
  205.           bIOThreadCreated = TRUE;
  206.           DosSetPriority(PRTYS_THREAD,
  207.                          PRTYC_TIMECRITICAL,
  208.                          01L,
  209.                          psib->ThreadID);
  210.           /*
  211.            * Now connect SIB to list, (the list is under semaphore
  212.            * control).
  213.            */
  214.           rc = DosRequestMutexSem(hmtxGlobalData, SEM_INDEFINITE_WAIT);
  215.           if (!rc)
  216.             { /* Update SIB list */
  217.  
  218.               psib->pnxtSIB = pSIB_list_head;
  219.               pSIB_list_head = psib;
  220.               DosReleaseMutexSem(hmtxGlobalData);
  221.  
  222.             } /* Update SIB list */
  223.         } /* IO Thread created */
  224.  
  225.       if (rc)
  226.         { /* Error - Clean up */
  227.  
  228.           if (bIOThreadCreated)
  229.             { /* kill the read write thread */
  230.  
  231.               psib->ulActionFlags |= SIBACTFLG_KILL;
  232.               DosPostEventSem(psib->hevStop);
  233.               DosWaitThread(&psib->ThreadID, DCWW_WAIT);
  234.  
  235.             } /* kill the read write thread */
  236.  
  237.           if (bHevStopCreated)
  238.             {
  239.               DosCloseEventSem(psib->hevStop);
  240.             }
  241.  
  242.           if (bHevCmdSyncCreated)
  243.             {
  244.               DosCloseEventSem(psib->hevCmdSync);
  245.             }
  246.  
  247.           DosRequestMutexSem(hmtxGlobalData, SEM_INDEFINITE_WAIT);
  248.           HhpFreeMem(hHeap, psib);
  249.           DosReleaseMutexSem(hmtxGlobalData);
  250.  
  251.         } /* Error - Clean up */
  252.  
  253.     } /* we have sib and espcb */
  254.  
  255.   return(rc);
  256.  
  257. } /* End of ShcCreate */
  258.