ipc/dde_mem.c

   1 /***************************************************************************
   2  * Copyright 1995, Technion, Israel Institute of Technology
   3  * Electrical Eng, Software Lab.
   4  * Author:    Michael Veksler.
   5  ***************************************************************************
   6  * File:      dde_mem.c
   7  * Purpose :  shared DDE memory functionality for DDE
   8  ***************************************************************************
   9  */
  10 #ifdef CONFIG_IPC
  11
  12 #include <stdio.h>
  13 #include <stddebug.h>
  14 #include <debug.h>
  15 #include <assert.h>
  16 #include "ldt.h"
  17 #include "shm_main_blk.h"
  18 #include "shm_fragment.h"
  19 #include "shm_semaph.h"
  20 #include "dde_mem.h"
  21 #include "bit_array.h"
  22
  23 #define SEGPTR2HANDLE_INFO(sptr) ( (struct handle_info*)PTR_SEG_TO_LIN(sptr) )
  24
  25 #define HINFO2DATAPTR(h_info_ptr) ( (void*) ( (char*)h_info_ptr +           \
  26                                              sizeof(struct handle_info) ) )
  27 #define DDE_MEM_IDX(handle) ((handle)& 0x7fff)
  28 #define DDE_MEM_HANDLE(idx) ((idx) | 0x8000)
  29 #define DDE_MEM_INFO(handle) (main_block->handles[ DDE_MEM_IDX(handle) ])
  30 /* List of shared handles.
  31  * This entry resides on the shared memory, the data comes right
  32  * after the `handle_info'.
  33  * The entry is on the same block as the actual data.
  34  * The `next' field gives relative reference (relative to the start of
  35  * the blcok.
  36  */
  37 struct handle_info {
  38         WORD lock_count;
  39         WORD flags;
  40         int size;               /* size of the data (net)*/
  41 };
  42
  43 static bit_array free_handles;
  44 int debug_last_handle_size= 0;  /* for debugging purpose only */
  45
  46
  47 /* locate_handle:
  48  *   locate a shared memory handle.
  49  * Application:
  50  *   The handle is first searched for in attached blocks.
  51  *   At the beginning, only blocks owned by this process are
  52  *   attached.
  53  *   If a handle is not found, new blocks are attached.
  54  * Arguments:
  55  *   h    - the handle.
  56  * RETURN: pointer to handle info.
  57  */
  58 static struct handle_info *locate_handle(HGLOBAL h, struct local_shm_map *map)
  59 {
  60   struct shm_block *block;
  61
  62   dprintf_global(stddeb,"shm:locate_handle(0x%04x)\n", h);
  63
  64
  65   if (SampleBit( &free_handles, DDE_MEM_IDX(h)) == 0) {
  66      dprintf_global(stddeb, "shm:locate_handle: return NULL\n");
  67      return NULL;                  /* free!!! */
  68   }
  69
  70   block= shm_locate_block(DDE_MEM_INFO(h).shmid, map);
  71   if (block == NULL) {
  72       /* nothing found */
  73       dprintf_global(stddeb, "shm:locate_handle: return NULL\n");
  74       return NULL;
  75   }
  76
  77   return (struct handle_info *) REL2PTR(block, DDE_MEM_INFO(h).rel);
  78
  79 }
  80
  81 /* dde_alloc_handle: allocate shared DDE handle */
  82 static HGLOBAL dde_alloc_handle()
  83 {
  84   int bit_nr;
  85
  86   bit_nr= AllocateBit( &free_handles);
  87
  88   if (bit_nr != -1)
  89      return DDE_MEM_HANDLE(bit_nr);
  90
  91   dprintf_global(stddeb,"dde_alloc_handle: no free DDE handle found\n");
  92   return 0;
  93 }
  94 /**********************************************************************
  95  *                                      DDE_malloc
  96  */
  97 void *
  98 DDE_malloc(unsigned int flags, unsigned long size, SHMDATA *shmdata)
  99 {
 100     int shmid;
 101     struct shm_block *block;
 102     struct handle_info *h_info;
 103     struct local_shm_map *curr;
 104     HGLOBAL handle;
 105
 106     dprintf_global(stddeb,"DDE_malloc flags %4X, size %ld\n", flags, size);
 107     DDE_IPC_init();             /* make sure main shm block allocated */
 108
 109     shm_write_wait(main_block->proc[curr_proc_idx].sem);
 110
 111     /* Try to find fragment big enough for `size' */
 112     /* iterate through all local shm blocks, and try to allocate
 113        the fragment */
 114
 115     h_info= NULL;
 116     for (curr=  shm_map ; curr != NULL ; curr= curr->next) {
 117        if (curr->proc_idx == curr_proc_idx) {
 118           h_info= (struct handle_info *)
 119              shm_FragPtrAlloc(curr->ptr, size+sizeof(struct handle_info));
 120           if (h_info!=NULL) {
 121              shmid= curr->shm_id;
 122              break;
 123           }
 124        }
 125     }
 126
 127     if (h_info == NULL) {
 128
 129        block= shm_create_block(0, size+sizeof(struct handle_info), &shmid);
 130        if (block==NULL) {
 131           shm_write_signal(main_block->proc[curr_proc_idx].sem);
 132           return 0;
 133        }
 134        /* put the new block in the linked list */
 135        block->next_shm_id= main_block->proc[curr_proc_idx].shmid;
 136        main_block->proc[curr_proc_idx].shmid= shmid;
 137        h_info= (struct handle_info *)
 138           shm_FragPtrAlloc(block, size+sizeof(struct handle_info));
 139        if (h_info==NULL) {
 140           fprintf(stderr,"DDE_malloc: BUG! unallocated fragment\n");
 141           shm_write_signal(main_block->proc[curr_proc_idx].sem);
 142           return 0;
 143        }
 144     } else {
 145        block= curr->ptr;
 146     }
 147
 148     /* Here we have an allocated fragment */
 149     h_info->flags= flags;
 150     h_info->lock_count= 0;
 151     h_info->size= size;
 152     handle= dde_alloc_handle();
 153
 154     if (handle) {
 155        dprintf_global(stddeb,
 156                       "DDE_malloc returning handle=0x%4x, ptr=0x%08lx\n",
 157                       (int)handle, (long) HINFO2DATAPTR(h_info));
 158        DDE_MEM_INFO(handle).rel=  PTR2REL(block, h_info);
 159        DDE_MEM_INFO(handle).shmid= shmid;
 160     }
 161     else
 162        dprintf_global(stddeb,"DDE_malloc failed\n");
 163
 164     shm_write_signal(main_block->proc[curr_proc_idx].sem);
 165
 166     shmdata->handle= handle;
 167     return (char *)HINFO2DATAPTR(h_info);
 168 }
 169
 170 HGLOBAL DDE_GlobalFree(HGLOBAL h)
 171 {
 172   struct handle_info *h_info;
 173   int handle_index= h & 0x7fff;
 174   struct local_shm_map map;
 175
 176   dprintf_global(stddeb,"DDE_GlobalFree(0x%04x)\n",h);
 177
 178   if (h==0)
 179      return 0;
 180
 181   h_info= locate_handle(h, &map);
 182   if (h_info == NULL)
 183       return h;
 184
 185   shm_write_wait(main_block->proc[map.proc_idx].sem);
 186
 187   shm_FragPtrFree(map.ptr, (struct shm_fragment *) h_info);
 188
 189   AssignBit( &free_handles, handle_index, 0);
 190
 191   /* FIXME: must free the shm block some day. */
 192   shm_write_signal(main_block->proc[map.proc_idx].sem);
 193   return 0;
 194 }
 195
 196 WORD DDE_SyncHandle(HGLOBAL handle, WORD sel)
 197
 198 {
 199     struct handle_info *h_info;
 200     void *local_ptr;
 201     ldt_entry entry;
 202
 203     h_info= locate_handle(handle, NULL);
 204     local_ptr= (void *)GET_SEL_BASE(sel);
 205
 206
 207     if (h_info == NULL)
 208         return 0;
 209
 210     if (local_ptr == (void *) HINFO2DATAPTR(h_info))
 211         return sel;
 212
 213     /* need syncronization ! */
 214     LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
 215     entry.base= (unsigned long) HINFO2DATAPTR(h_info);
 216     LDT_SetEntry( SELECTOR_TO_ENTRY(sel), &entry );
 217
 218     return sel;
 219 }
 220
 221 /*
 222  * DDE_AttachHandle:
 223  * Attach shm memory (The data must not be already attached).
 224  * Parameters:
 225  *   handle - the memory to attach.
 226  *   segptr - in not null, return SEGPTR to the same block.
 227  * return value:
 228  *   32 bit pointer to the memory.
 229  */
 230
 231 void *DDE_AttachHandle(HGLOBAL handle, SEGPTR *segptr)
 232 {
 233   struct handle_info *h_info;
 234   SHMDATA shmdata;
 235   void *ptr;
 236   HGLOBAL hOwner = GetCurrentPDB();
 237
 238   assert(is_dde_handle(handle));
 239   if (segptr != NULL)
 240       *segptr=0;
 241
 242   dprintf_global(stddeb,"DDE_AttachHandle(%04x)\n",handle);
 243   h_info=locate_handle(handle, NULL);
 244
 245   if (h_info == NULL)
 246       return NULL;
 247
 248   if ( !(h_info->flags & GMEM_DDESHARE) ) {
 249       fprintf(stderr,"DDE_AttachHandle: Corrupted memory handle info\n");
 250       return NULL;
 251   }
 252
 253   dprintf_global(stddeb,"DDE_AttachHandle: h_info=%06lx\n",(long)h_info);
 254
 255   shmdata.handle= handle;
 256   shmdata.shmid= DDE_MEM_INFO(handle).shmid;
 257
 258   ptr= HINFO2DATAPTR(h_info);
 259   /* Allocate the selector(s) */
 260   if (! GLOBAL_CreateBlock( h_info->flags, ptr, h_info->size, hOwner,
 261                             FALSE, FALSE, FALSE, &shmdata))
 262       return NULL;
 263
 264   if (segptr != NULL)
 265       *segptr= (SEGPTR)MAKELONG( 0, shmdata.sel);
 266
 267   if (debugging_dde)
 268       debug_last_handle_size= h_info->size;
 269
 270   dprintf_global(stddeb,"DDE_AttachHandle returns ptr=0x%08lx\n", (long)ptr);
 271
 272   return (LPSTR)ptr;
 273
 274 }
 275
 276 void DDE_mem_init()
 277 {
 278   int nr_of_bits;
 279
 280   shm_init();
 281
 282   nr_of_bits= BITS_PER_BYTE * sizeof(main_block->free_handles);
 283   AssembleArray( &free_handles, main_block->free_handles, nr_of_bits);
 284 }
 285
 286 #endif  /* CONFIG_IPC */