home *** CD-ROM | disk | FTP | other *** search
/ PC Online 1999 November / PCONLINE_11_99.ISO / filesbbs / OS2 / CDR18A24.ZIP / source / fifo.c.diff < prev    next >
Encoding:
Text File  |  1999-08-22  |  6.8 KB  |  280 lines
  1. *** d:/os2/tmp/fifo.c_a00037    Sun Aug 22 11:49:48 1999
  2. --- d:/os2/tmp/fifo.c_b00037    Sun Aug 22 11:49:48 1999
  3. ***************
  4. *** 31,37 ****
  5.   #define    DEBUG
  6.   /*#define    XDEBUG*/
  7.   #include <mconfig.h>
  8. ! #if    !defined(HAVE_SMMAP) && !defined(HAVE_USGSHM)
  9.   #undef    FIFO            /* We cannot have a FIFO on this platform */
  10.   #endif
  11.   #ifdef    FIFO
  12. --- 31,37 ----
  13.   #define    DEBUG
  14.   /*#define    XDEBUG*/
  15.   #include <mconfig.h>
  16. ! #if    !defined(HAVE_SMMAP) && !defined(HAVE_USGSHM) && !defined(HAVE_ALLOCSHAREDMEM)
  17.   #undef    FIFO            /* We cannot have a FIFO on this platform */
  18.   #endif
  19.   #ifdef    FIFO
  20. ***************
  21. *** 46,51 ****
  22. --- 46,57 ----
  23.   #    undef    USE_USGSHM    /* mmap() is preferred            */
  24.   #endif
  25.   
  26. + #ifdef HAVE_ALLOCSHAREDMEM /* This is for OS/2 */
  27. + #define     USE_OS2SHM
  28. + #    undef    USE_MMAP
  29. + #    undef    USE_USGSHM
  30. + #endif
  31. + 
  32.   #include <fctldefs.h>
  33.   #include <sys/types.h>
  34.   #if defined(HAVE_SMMAP) && defined(USE_MMAP)
  35. ***************
  36. *** 129,134 ****
  37. --- 135,141 ----
  38.   #define    READER_MAXWAIT    (240*SECS)    /* 240 seconds max wait for reader */
  39.   
  40.   LOCAL    char    *buf;
  41. + 
  42.   LOCAL    char    *bufbase;
  43.   LOCAL    char    *bufend;
  44.   LOCAL    long    buflen;
  45. ***************
  46. *** 143,148 ****
  47. --- 150,159 ----
  48.   #ifdef    USE_USGSHM
  49.   LOCAL    char*    mkshm        __PR((int size));
  50.   #endif
  51. + #ifdef    USE_OS2SHM
  52. + LOCAL    char*    mkos2shm        __PR((int size));
  53. + #endif
  54. + 
  55.   EXPORT    BOOL    init_faio    __PR((int tracks, track_t *track, int));
  56.   EXPORT    BOOL    await_faio    __PR((void));
  57.   EXPORT    void    kill_faio    __PR((void));
  58. ***************
  59. *** 182,187 ****
  60. --- 193,202 ----
  61.   #if    defined(USE_USGSHM)
  62.       buf = mkshm(buflen);
  63.   #endif
  64. + #if    defined(USE_OS2SHM)
  65. +     buf = mkos2shm(buflen);
  66. + #endif
  67. + 
  68.       bufbase = buf;
  69.       bufend = buf + buflen;
  70.       EDEBUG(("buf: %X bufend: %X, buflen: %ld\n", buf, bufend, buflen));
  71. ***************
  72. *** 193,198 ****
  73. --- 208,214 ----
  74.        * Dirty the whole buffer. This can die with various signals if
  75.        * we're trying to lock too much memory
  76.        */
  77. + 
  78.       fillbytes(buf, buflen, '\0');
  79.   
  80.   #ifdef    XDEBUG
  81. ***************
  82. *** 268,281 ****
  83.        * Although SHM_LOCK is standard, it seems that all versions of AIX
  84.        * ommit this definition.
  85.        */
  86.       if (shmctl(id, SHM_LOCK, 0) < 0)
  87. !         comerr("shmctl failed to lock shared memory segment\n");
  88.   #endif
  89.   
  90.       return (addr);
  91.   }
  92.   #endif
  93.   
  94.   LOCAL    int    faio_buffers;
  95.   LOCAL    int    faio_buf_size;
  96.   LOCAL    int    buf_idx;
  97. --- 284,316 ----
  98.        * Although SHM_LOCK is standard, it seems that all versions of AIX
  99.        * ommit this definition.
  100.        */
  101. + 
  102.       if (shmctl(id, SHM_LOCK, 0) < 0)
  103. !     comerr("shmctl failed to lock shared memory segment\n");
  104.   #endif
  105.   
  106.       return (addr);
  107.   }
  108.   #endif
  109.   
  110. + #ifdef USE_OS2SHM
  111. + LOCAL char *
  112. + mkos2shm(size)
  113. +     int    size;
  114. + {
  115. +     char    *addr;
  116. +     /* The OS/2 implementation of shm (using shm.dll) limits the size of one shared
  117. +        memory segment to 0x3fa000 (aprox. 4MBytes). Using OS/2 native API we have
  118. +        no such restriction so I decided to use it allowing fifos of arbitrary size.  
  119. +        */
  120. +     if(DosAllocSharedMem(&addr,NULL,size,0X100L | 0x1L | 0x2L | 0x10L)) 
  121. +       comerr("\nDosAllocSharedMem() failed\n");
  122. + 
  123. +     if (debug) errmsgno(EX_BAD, "shared memory allocated at address: %x\n", addr);    
  124. +     return (addr);
  125. + }
  126. + #endif
  127. + 
  128.   LOCAL    int    faio_buffers;
  129.   LOCAL    int    faio_buf_size;
  130.   LOCAL    int    buf_idx;
  131. ***************
  132. *** 330,336 ****
  133.                           MIN_BUFFERS*bufsize/1024);
  134.           return (FALSE);
  135.       }
  136. !     
  137.       if (debug)
  138.           printf("Using %d buffers of %d bytes.\n", faio_buffers, faio_buf_size);
  139.   
  140. --- 365,371 ----
  141.                           MIN_BUFFERS*bufsize/1024);
  142.           return (FALSE);
  143.       }
  144. ! 
  145.       if (debug)
  146.           printf("Using %d buffers of %d bytes.\n", faio_buffers, faio_buf_size);
  147.   
  148. ***************
  149. *** 344,349 ****
  150. --- 379,385 ----
  151.           f->bufp = base;
  152.           f->fd = -1;
  153.       }
  154. + 
  155.       sp = (struct faio_stats *)f;    /* point past headers */
  156.       sp->gets = sp->puts = sp->done = 0L;
  157.   
  158. ***************
  159. *** 354,360 ****
  160.       if (faio_pid == 0) {
  161.           /* child process */
  162.           raisepri(1);        /* almost max priority */
  163. ! 
  164.           /* Ignoring SIGALRM cures the SCO usleep() bug */
  165.   /*        signal(SIGALRM, SIG_IGN);*/
  166.           faio_reader(tracks, track);
  167. --- 390,398 ----
  168.       if (faio_pid == 0) {
  169.           /* child process */
  170.           raisepri(1);        /* almost max priority */
  171. ! #ifdef USE_OS2SHM
  172. !         DosGetSharedMem(buf,3);/* PAG_READ|PAG_WRITE */
  173. ! #endif
  174.           /* Ignoring SIGALRM cures the SCO usleep() bug */
  175.   /*        signal(SIGALRM, SIG_IGN);*/
  176.           faio_reader(tracks, track);
  177. ***************
  178. *** 363,368 ****
  179. --- 401,407 ----
  180.           /* close all file-descriptors that only the child will use */
  181.           for (n = 1; n <= tracks; n++)
  182.               close(track[n].f);
  183. +         /*printf("Init 2... PID: %d, f: %X, &buf: %X, buf: %X, *buf: %X\n",faio_pid,1,&buf, (int)buf,*buf);*/
  184.       }
  185.   
  186.       return (TRUE);
  187. ***************
  188. *** 420,432 ****
  189.       int    trackno;
  190.   
  191.       if (debug)
  192. !         printf("\nfaio_reader starting\n");
  193.   
  194.       for (trackno = 1; trackno <= tracks; trackno++) {
  195.           if (debug)
  196.               printf("\nfaio_reader reading track %d\n", trackno);
  197.           faio_read_track(&track[trackno]);
  198.       }
  199.       sp->done++;
  200.       if (debug)
  201.           printf("\nfaio_reader all tracks read, exiting\n");
  202. --- 459,472 ----
  203.       int    trackno;
  204.   
  205.       if (debug)
  206. !         printf("\nfaio_reader starting, PID: %d\n",faio_pid);
  207.   
  208.       for (trackno = 1; trackno <= tracks; trackno++) {
  209.           if (debug)
  210.               printf("\nfaio_reader reading track %d\n", trackno);
  211.           faio_read_track(&track[trackno]);
  212.       }
  213. + 
  214.       sp->done++;
  215.       if (debug)
  216.           printf("\nfaio_reader all tracks read, exiting\n");
  217. ***************
  218. *** 435,443 ****
  219.       if (sp->gets == 0)
  220.           faio_ref(faio_buffers - 1)->owner = owner_reader;
  221.   
  222.       if (debug)
  223. !         error("\faio_reader _exit(0)\n");
  224. !     _exit(0);
  225.   }
  226.   
  227.   #ifndef    faio_ref
  228. --- 475,488 ----
  229.       if (sp->gets == 0)
  230.           faio_ref(faio_buffers - 1)->owner = owner_reader;
  231.   
  232. + #ifdef USE_OS2SHM
  233. +     DosFreeMem(buf);
  234. +     sleep(30000); /* If calling _exit() here the parent process seems to be blocked */
  235. + #endif
  236.       if (debug)
  237. !         error("\nfaio_reader _exit(0)\n");
  238. ! 
  239. !         _exit(0);     
  240.   }
  241.   
  242.   #ifndef    faio_ref
  243. ***************
  244. *** 481,486 ****
  245. --- 526,532 ----
  246.           if (l <= 0)
  247.               break;
  248.           bytes_read += l;
  249. + 
  250.       } while (tracksize < 0 || bytes_read < tracksize);
  251.   
  252.       close(fd);    /* Don't keep files open longer than neccesary */
  253. ***************
  254. *** 495,506 ****
  255.   {
  256.       unsigned long max_loops;
  257.   
  258. !     if (f->owner == s)
  259. !         return;        /* return immediately if the buffer is ours */
  260.   
  261.       if (s == owner_reader)
  262.           sp->empty++;
  263. !     else
  264.           sp->full++;
  265.   
  266.       max_loops = max_wait / delay + 1;
  267. --- 541,552 ----
  268.   {
  269.       unsigned long max_loops;
  270.   
  271. !     if (f->owner == s)
  272. !       return;        /* return immediately if the buffer is ours */
  273.   
  274.       if (s == owner_reader)
  275.           sp->empty++;
  276. !     else 
  277.           sp->full++;
  278.   
  279.       max_loops = max_wait / delay + 1;
  280.