memory/linear.c

   1 static char RCSId[] = "$Id$";
   2 static char Copyright[] = "Copyright  Robert J. Amstadt, 1994";
   3
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include "prototypes.h"
   8 #include "heap.h"
   9 #include "segmem.h"
  10
  11 #ifdef HAVE_IPC
  12 static key_t MemoryKeys[SHMSEG];        /* Keep track of keys were using */
  13 static int   LinearInitialized = 0;
  14 #endif
  15
  16 \f
  17 #ifdef HAVE_IPC
  18 /**********************************************************************
  19  *                                      LinearFindSpace
  20  */
  21 int
  22 LinearFindSpace(int n_segments)
  23 {
  24     int i, n;
  25
  26     if (!LinearInitialized)
  27     {
  28         memset(MemoryKeys, -1, sizeof(MemoryKeys));
  29         return 0;
  30     }
  31
  32     for (i = 0, n = 0; i < SHMSEG, n != n_segments; i++)
  33     {
  34         if (MemoryKeys[i] < 0)
  35             n++;
  36         else
  37             n = 0;
  38     }
  39
  40     if (n != n_segments)
  41         return -1;
  42     else
  43         return i - n;
  44 }
  45 #endif /* HAVE_IPC */
  46 \f
  47 /**********************************************************************
  48  *                                      GlobalLinearLock
  49  *
  50  * OK, this is an evil beast.  We will do one of two things:
  51  *
  52  *      1. If the data item <= 64k, then just call GlobalLock().
  53  *      2. If the data item > 64k, then map memory.
  54  */
  55 void *
  56 GlobalLinearLock(unsigned int block)
  57 {
  58     GDESC *g, *g_first;
  59     int loc_idx;
  60     unsigned long addr;
  61     int i;
  62
  63     /******************************************************************
  64      * Get GDESC for this block.
  65      */
  66     g_first = GlobalGetGDesc(block);
  67     if (g_first == NULL)
  68         return 0;
  69
  70     /******************************************************************
  71      * Is block less then 64k in length?
  72      */
  73     if (g_first->sequence != 1 || g_first->length == 1)
  74     {
  75         return (void *) GlobalLock(block);
  76     }
  77
  78     /******************************************************************
  79      * If there is already a linear lock on this memory, then
  80      * just return a pointer to it.
  81      */
  82     if (g_first->linear_count)
  83     {
  84         g_first->linear_count++;
  85         return g_first->linear_addr;
  86     }
  87
  88     /******************************************************************
  89      * No luck.  We need to do the linear mapping right now.
  90      */
  91 #ifdef HAVE_IPC
  92     loc_idx = LinearFindSpace(g_first->length);
  93     if (loc_idx < 0)
  94         return NULL;
  95
  96     addr = (unsigned long) SHM_RANGE_START + (0x10000 * loc_idx);
  97     g = g_first;
  98     for (i = loc_idx;
  99          i < loc_idx + g_first->length;
 100          i++, addr += 0x10000, g = g->next)
 101     {
 102         if ((MemoryKeys[i] = IPCCopySelector(g->handle >> 3, addr, 0)) < 0)
 103             return NULL;
 104         g->linear_addr = (void *) addr;
 105         g->linear_count = 1;
 106     }
 107 #endif /* HAVE_IPC */
 108
 109     return g_first->linear_addr;
 110 }
 111 \f
 112 /**********************************************************************
 113  *                                      GlobalLinearUnlock
 114  *
 115  */
 116 unsigned int
 117 GlobalLinearUnlock(unsigned int block)
 118 {
 119     GDESC *g, *g_first;
 120     int loc_idx;
 121     int i;
 122
 123     /******************************************************************
 124      * Get GDESC for this block.
 125      */
 126     g_first = GlobalGetGDesc(block);
 127     if (g_first == NULL)
 128         return block;
 129
 130     /******************************************************************
 131      * Is block less then 64k in length?
 132      */
 133     if (g_first->sequence != 1 || g_first->length == 1)
 134     {
 135         return GlobalUnlock(block);
 136     }
 137
 138     /******************************************************************
 139      * Make sure we have a lock on this block.
 140      */
 141 #ifdef HAVE_IPC
 142     if (g_first->linear_count > 1)
 143     {
 144         g_first->linear_count--;
 145     }
 146     else if (g_first->linear_count == 1)
 147     {
 148         g = g_first;
 149         loc_idx = (((unsigned int) g_first - (unsigned int) SHM_RANGE_START)
 150                    / 0x10000);
 151         for (i = 0; i < g_first->length; i++, g = g->next)
 152         {
 153             shmdt(g->linear_addr);
 154             g->linear_addr = NULL;
 155             MemoryKeys[i] = -1;
 156         }
 157
 158         g_first->linear_count = 0;
 159         return 0;
 160     }
 161 #endif /* HAVE_IPC */
 162
 163     return 0;
 164 }
 165 /**********************************************************************/
 166 \f
 167 LinearTest()
 168 {
 169 #if 0
 170     unsigned int handle;
 171     int *seg_ptr;
 172     int *lin_ptr;
 173     int seg, i;
 174     int *p;
 175
 176     handle = GlobalAlloc(0, 0x40000);
 177     seg_ptr = GlobalLock(handle);
 178     lin_ptr = GlobalLinearLock(handle);
 179
 180     for (seg = 0; seg < 4; seg++)
 181     {
 182         p = (int *) ((char *) seg_ptr + (0x80000 * seg));
 183         for (i = 0; i < (0x10000 / sizeof(int)); i++, p++)
 184             *p = (seg * (0x10000 / sizeof(int))) + i;
 185     }
 186
 187     p = lin_ptr;
 188     for (i = 0; i < (0x40000 / sizeof(int)); i++, p++)
 189     {
 190         if (*p != i)
 191             printf("lin_ptr[%x] = %x\n", i, *p);
 192     }
 193 #endif
 194 }