Changeset 1432 for trunk/src


Ignore:
Timestamp:
Oct 25, 1999, 12:53:25 AM (26 years ago)
Author:
sandervl
Message:

Shared memory mapping changes

Location:
trunk/src/kernel32
Files:
2 added
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/hmmmap.cpp

    r712 r1432  
    1 /* $Id: hmmmap.cpp,v 1.6 1999-08-27 16:51:00 sandervl Exp $ */
     1/* $Id: hmmmap.cpp,v 1.7 1999-10-24 22:51:21 sandervl Exp $ */
    22
    33/*
    … …  
    3131#include "HMMMap.h"
    3232#include "mmap.h"
     33#include "heapshared.h"
    3334
    3435/*****************************************************************************
    … …  
    6465
    6566        dprintf(("CreateFileMappingA: invalid parameter (combination)!"));
     67        dprintf(("Parameters: %x %x %x %x %s", hFile, protect, size_high, size_low, name));
    6668        return ERROR_INVALID_PARAMETER;
    6769  }

  • trunk/src/kernel32/initterm.cpp

    r1410 r1432  
    1 /* $Id: initterm.cpp,v 1.16 1999-10-23 12:34:46 sandervl Exp $ */
     1/* $Id: initterm.cpp,v 1.17 1999-10-24 22:51:21 sandervl Exp $ */
    22
    33/*
    … …  
    4040#include <odinlx.h>
    4141#include "oslibmisc.h"
     42#include "heapshared.h"
    4243
    4344/*-------------------------------------------------------------------*/
    … …  
    101102            CheckVersionFromHMOD(PE2LX_VERSION, hModule); /*PLF Wed  98-03-18 05:28:48*/
    102103
     104            if(InitializeSharedHeap() == FALSE)
     105                return 0UL;
     106
    103107            if(RegisterLxDll(hModule, 0, 0) == FALSE)
    104108                return 0UL;

  • trunk/src/kernel32/makefile

    r1410 r1432  
    1 # $Id: makefile,v 1.45 1999-10-23 12:34:47 sandervl Exp $
     1# $Id: makefile,v 1.46 1999-10-24 22:51:21 sandervl Exp $
    22
    33#
    … …  
    2323CONBUFFER.OBJ CONOUT.OBJ UNICODE.OBJ network.OBJ DEVIO.OBJ \
    2424profile.obj THREAD.OBJ virtual.obj THUNK.OBJ OBSOLETE.OBJ COMM.OBJ\
    25 MESSAGE.OBJ RESOURCE.OBJ EXCEPTIONS.OBJ \
     25MESSAGE.OBJ RESOURCE.OBJ EXCEPTIONS.OBJ heapshared.obj \
    2626LFILE.OBJ NPIPE.OBJ oslibdos.obj oslibmisc.obj MISC.OBJ EXCEPTUTIL.OBJ \
    2727LANG.OBJ ICCIO.OBJ MAP.OBJ WIN32UTIL.OBJ heap.OBJ heapstring.obj \
    … …  
    100100
    101101atom.obj: atom.cpp \
    102     $(PDWIN32_INCLUDE)\unicode.h
     102    $(PDWIN32_INCLUDE)\unicode.h 
    103103
    104104time.obj: time.cpp \
    … …  
    132132    os2heap.h
    133133
    134 initterm.OBJ: .\initterm.cpp initterm.h
     134initterm.OBJ: .\initterm.cpp initterm.h  heapshared.h
    135135
    136136thunk.OBJ: \
    … …  
    311311        .\hmopen32.h
    312312
    313 hmmmap.obj: hmmmap.cpp hmdevice.h hmopen32.h mmap.h
     313hmmmap.obj: hmmmap.cpp hmdevice.h hmopen32.h mmap.h heapshared.h
    314314
    315315conprop.OBJ: \
    … …  
    324324
    325325virtual.obj:   virtual.cpp $(PDWIN32_INCLUDE)\win\virtual.h $(PDWIN32_INCLUDE)\handlemanager.h mmap.h
    326 mmap.obj:      mmap.cpp mmap.h $(PDWIN32_INCLUDE)\vmutex.h oslibdos.h
     326mmap.obj:      mmap.cpp mmap.h $(PDWIN32_INCLUDE)\vmutex.h oslibdos.h heapshared.h
    327327
    328328pefile.OBJ:    pefile.cpp $(PDWIN32_INCLUDE)\pefile.h $(PDWIN32_INCLUDE)\winres.h
    … …  
    362362toolhelp.obj: toolhelp.cpp
    363363
     364heapshared.obj: heapshared.cpp heapshared.h
     365
     366
    364367clean:
    365368        $(RM) *.OBJ *.LIB *.dll *.lrf *.res *.map *.pch

  • trunk/src/kernel32/mmap.cpp

    r770 r1432  
    1 /* $Id: mmap.cpp,v 1.18 1999-09-01 00:03:51 phaller Exp $ */
     1/* $Id: mmap.cpp,v 1.19 1999-10-24 22:51:21 sandervl Exp $ */
    22
    33/*
    … …  
    3030#include "oslibdos.h"
    3131
    32 VMutex globalmapMutex;
    33 VMutex globalviewMutex;
     32//Global DLL Data
     33#pragma data_seg(_GLOBALDATA)
     34Win32MemMapView *Win32MemMapView::mapviews = NULL;
     35Win32MemMap     *Win32MemMap::memmaps = NULL;
     36VMutex           globalmapMutex(VMUTEX_SHARED);
     37VMutex           globalviewMutex(VMUTEX_SHARED);
     38#pragma data_seg()
    3439
    3540//******************************************************************************
    … …  
    4853  mSize      = size;
    4954  mProtFlags = fdwProtect;
     55  mProcessId  = GetCurrentProcess();
    5056
    5157  if(lpszName) {
    52         lpszMapName = (char *)malloc(strlen(lpszName)+1);
     58        lpszMapName = (char *)_smalloc(strlen(lpszName)+1);
    5359        strcpy(lpszMapName, lpszName);
    5460  }
    … …  
    6268  if(hMemFile != -1)
    6369  {
    64         if(DuplicateHandle(GetCurrentProcess(), hMemFile, GetCurrentProcess(),
     70        if(DuplicateHandle(mProcessId, hMemFile, GetCurrentProcess(),
    6571                           &hMemFile, 0, FALSE, DUPLICATE_SAME_ACCESS) == FALSE)
    6672        {
    … …  
    8793Win32MemMap::~Win32MemMap()
    8894{
    89   for(int i=0;i<nrMappings;i++) {
    90         Win32MemMapView::deleteView(this); //delete all views of our memory mapped file
    91   }
     95  Win32MemMapView::deleteViews(this); //delete all views of our memory mapped file
     96
    9297  mapMutex.enter();
    9398  if(lpszMapName) {
    … …  
    95100  }
    96101  if(pMapping) {
    97         VirtualFree(pMapping, mSize, MEM_RELEASE);
     102        if(lpszMapName) {
     103                OSLibDosFreeMem(pMapping);
     104        }
     105        else    VirtualFree(pMapping, mSize, MEM_RELEASE);
     106
    98107        pMapping = NULL;
    99108  }
    … …  
    206215}
    207216//******************************************************************************
    208 //todo: unalias memory
    209217//******************************************************************************
    210218BOOL Win32MemMap::unmapViewOfFile(Win32MemMapView *view)
    … …  
    231239LPVOID Win32MemMap::mapViewOfFile(ULONG size, ULONG offset, ULONG fdwAccess)
    232240{
     241 DWORD processId = GetCurrentProcess();
     242
    233243  mapMutex.enter();
    234244  ULONG memFlags = (mProtFlags & (PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY));
    … …  
    270280        //     when allocating memory with the PAG_ANY bit set. (without this
    271281        //     flag it will also crash)
    272         pMapping = VirtualAlloc(0, mSize, fAlloc, PAGE_READWRITE);
     282        if(lpszMapName) {
     283                pMapping = VirtualAllocShared(mSize, fAlloc, PAGE_READWRITE, lpszMapName);
     284        }
     285        else {
     286                pMapping = VirtualAlloc(0, mSize, fAlloc, PAGE_READWRITE);
     287        }
    273288        if(pMapping == NULL) {
    274289                dprintf(("Win32MemMap::mapFileView: VirtualAlloc %x %x %x failed!", mSize, fAlloc, memFlags));
    … …  
    375390Win32MemMap *Win32MemMap::findMap(LPSTR lpszName)
    376391{
     392  if(lpszName == NULL)
     393        return NULL;
     394
    377395  globalmapMutex.enter();
    378396  Win32MemMap *map = memmaps;
    … …  
    414432void Win32MemMap::deleteAll()
    415433{
    416   while(memmaps) {
    417         CloseHandle(memmaps->hMemMap);
    418   }
    419 }
    420 //******************************************************************************
    421 //******************************************************************************
    422 Win32MemMap *Win32MemMap::memmaps = NULL;
    423 
     434 Win32MemMap *map = memmaps, *nextmap;
     435 DWORD processId = GetCurrentProcess();
     436
     437  //delete all maps created by this process
     438  while(map) {
     439        nextmap = map->next;
     440        if(map->getProcessId() == processId) {
     441                CloseHandle(memmaps->hMemMap);
     442        }
     443        else {
     444                //delete all views created by this process for this map
     445                Win32MemMapView::deleteViews(map);
     446        }
     447        map = nextmap;
     448  }
     449}
    424450//******************************************************************************
    425451//******************************************************************************
    … …  
    435461  mSize    = size;
    436462  mOffset  = offset;
     463  mProcessId = GetCurrentProcess();
    437464
    438465  switch(fdwAccess) {
    … …  
    447474        break;
    448475  }
     476  if(map->getMemName() != NULL) {
     477        //shared memory map, so map it into our address space
     478        if(OSLibDosGetNamedSharedMem((LPVOID *)&viewaddr, map->getMemName()) != OSLIB_NOERROR) {
     479                dprintf(("new OSLibDosGetNamedSharedMem FAILED"));
     480                SetLastError(ERROR_NOT_ENOUGH_MEMORY);
     481                errorState = 1;
     482                return;
     483        }
     484  }
     485 
    449486  if(OSLibDosAliasMem(viewaddr, size, &pMapView, accessAttr) != OSLIB_NOERROR) {
    450487        dprintf(("new OSLibDosAliasMem FAILED"));
    … …  
    506543//******************************************************************************
    507544//******************************************************************************
    508 void Win32MemMapView::deleteView(Win32MemMap *map)
    509 {
     545void Win32MemMapView::deleteViews(Win32MemMap *map)
     546{
     547  DWORD processId = GetCurrentProcess();
     548
    510549  globalviewMutex.enter();
    511   Win32MemMapView *view = mapviews;
     550  Win32MemMapView *view = mapviews, *nextview;
    512551
    513552  if(view != NULL) {
    514553        while(view) {
    515                 if(view->getParentMap() == map)
     554                nextview = view->next;
     555                if(view->getParentMap() == map && view->getProcessId() == processId)
    516556                {
    517557                        globalviewMutex.leave();
    518558                        delete view;
    519                         return;
    520                 }
    521                 view = view->next;
     559                        globalviewMutex.enter();
     560                }
     561                view = nextview;
    522562        }
    523563  }
    … …  
    573613//******************************************************************************
    574614//******************************************************************************
    575 Win32MemMapView *Win32MemMapView::mapviews = NULL;
    576 
     615

  • trunk/src/kernel32/mmap.h

    r712 r1432  
    1 /* $Id: mmap.h,v 1.9 1999-08-27 16:51:00 sandervl Exp $ */
     1/* $Id: mmap.h,v 1.10 1999-10-24 22:51:22 sandervl Exp $ */
    22
    33/*
    … …  
    1414
    1515#include <vmutex.h>
     16#include "heapshared.h"
    1617
    1718#ifndef PAGE_SIZE
    … …  
    4546   DWORD  getProtFlags()                 { return mProtFlags; };
    4647   LPVOID getMappingAddr()               { return pMapping; };
     48   DWORD  getProcessId()                 { return mProcessId;};
    4749
    4850   void   AddRef()                       { ++referenced; };
    … …  
    5759static void deleteAll();
    5860
     61#ifdef __DEBUG_ALLOC__
     62        void *operator new(size_t size, const char *filename, size_t lineno)
     63        {
     64                return _umalloc(sharedHeap, size);
     65        }
     66        void operator delete(void *location, const char *filename, size_t lineno)
     67        {
     68                free(location);
     69        }
     70#else
     71        void *operator new(size_t size)
     72        {
     73                return _umalloc(sharedHeap, size);
     74        }
     75        void operator delete(void *location)
     76        {
     77                free(location);
     78        }
     79#endif
     80
    5981protected:
    6082   HFILE  hMemMap, hMemFile;
    6183   ULONG  mSize;
    6284   ULONG  mProtFlags;
     85   ULONG  mProcessId;
    6386   ULONG  mMapAccess;
    6487   LPSTR  lpszMapName;
    … …  
    92115
    93116Win32MemMap *getParentMap()              { return mParentMap;};
     117   DWORD  getProcessId()                 { return mProcessId;};
    94118
    95 static void             deleteView(Win32MemMap *map);
     119static void             deleteViews(Win32MemMap *map);
    96120static Win32MemMap     *findMapByView(ULONG address, ULONG *offset, ULONG accessType, Win32MemMapView **pView=NULL);
    97121static Win32MemMapView *findView(LPVOID address);
    98122
     123#ifdef __DEBUG_ALLOC__
     124        void *operator new(size_t size, const char *filename, size_t lineno)
     125        {
     126                return _umalloc(sharedHeap, size);
     127        }
     128        void operator delete(void *location, const char *filename, size_t lineno)
     129        {
     130                free(location);
     131        }
     132#else
     133        void *operator new(size_t size)
     134        {
     135                return _umalloc(sharedHeap, size);
     136        }
     137        void operator delete(void *location)
     138        {
     139                free(location);
     140        }
     141#endif
     142
    99143protected:
    100144   ULONG  mSize, errorState;
     145   ULONG  mProcessId;
    101146   ULONG  mfAccess, mOffset;
    102147   void  *pMapView;

  • trunk/src/kernel32/oslibdos.cpp

    r998 r1432  
    1 /* $Id: oslibdos.cpp,v 1.4 1999-09-21 11:00:22 phaller Exp $ */
     1/* $Id: oslibdos.cpp,v 1.5 1999-10-24 22:51:22 sandervl Exp $ */
    22
    33/*
    … …  
    4444}
    4545//******************************************************************************
     46//NOTE: If name == NULL, allocated gettable unnamed shared memory
     47//******************************************************************************
     48DWORD OSLibDosAllocSharedMem(LPVOID *lplpMemAddr, DWORD size, DWORD flags, LPSTR name)
     49{
     50 APIRET rc;
     51 char  *sharedmemname = NULL;
     52 
     53  if(name) {
     54        sharedmemname = (char *)malloc(strlen(name) + 16);
     55        strcpy(sharedmemname, "\\SHAREMEM\\");
     56        strcat(sharedmemname, name);
     57  }
     58  else  flags |= OBJ_GETTABLE;
     59 
     60  rc = DosAllocSharedMem(lplpMemAddr, sharedmemname, size, flags);
     61  if(name) {
     62        free(sharedmemname);
     63  }
     64  return rc;
     65}
     66//******************************************************************************
     67//NOTE: If name == NULL, assume gettable unnamed shared memory
     68//******************************************************************************
     69DWORD OSLibDosGetNamedSharedMem(LPVOID *lplpMemAddr, LPSTR name)
     70{
     71 APIRET rc;
     72 char  *sharedmemname = NULL;
     73 
     74  if(name) {
     75        sharedmemname = (char *)malloc(strlen(name) + 16);
     76        strcpy(sharedmemname, "\\SHAREMEM\\");
     77        strcat(sharedmemname, name);
     78        rc = DosGetNamedSharedMem(lplpMemAddr, sharedmemname, PAG_READ|PAG_WRITE);
     79        if(name) {
     80                free(sharedmemname);
     81        }
     82  }
     83  else  rc = DosGetSharedMem((LPVOID)*(DWORD *)lplpMemAddr, PAG_READ|PAG_WRITE);
     84
     85  return rc;
     86}
     87//******************************************************************************
    4688//******************************************************************************
    4789DWORD OSLibDosQueryMem(LPVOID lpMemAddr, DWORD *lpRangeSize, DWORD *lpAttr)

  • trunk/src/kernel32/oslibdos.h

    r998 r1432  
    1 /* $Id: oslibdos.h,v 1.4 1999-09-21 11:00:23 phaller Exp $ */
     1/* $Id: oslibdos.h,v 1.5 1999-10-24 22:51:22 sandervl Exp $ */
    22
    33/*
    … …  
    1919DWORD OSLibDosQueryMem(LPVOID lpMemAddr, DWORD *lpRangeSize, DWORD *lpAttr);
    2020DWORD OSLibDosSetMem(LPVOID lpMemAddr, DWORD size, DWORD flags);
     21DWORD OSLibDosAllocSharedMem(LPVOID *lplpMemAddr, DWORD size, DWORD flags, LPSTR name);
     22DWORD OSLibDosGetNamedSharedMem(LPVOID *lplpMemAddr, LPSTR name);
    2123
    2224BOOL OSLibDosGetFileAttributesEx(PSZ pszName, ULONG ulDummy, PVOID pBuffer);

  • trunk/src/kernel32/virtual.cpp

    r1395 r1432  
    1 /* $Id: virtual.cpp,v 1.20 1999-10-21 19:24:23 sandervl Exp $ */
     1/* $Id: virtual.cpp,v 1.21 1999-10-24 22:51:22 sandervl Exp $ */
    22
    33/*
    … …  
    676676  }
    677677}
     678
     679//******************************************************************************
     680//SvL: Private api
     681//******************************************************************************
     682LPVOID VirtualAllocShared(DWORD  cbSize, DWORD  fdwAllocationType,
     683                          DWORD  fdwProtect, LPSTR name)
     684{
     685  LPVOID Address;
     686  ULONG flag = 0, base;
     687  DWORD rc;
     688
     689  dprintf(("VirtualAllocShared: %x %x %x %s", cbSize, fdwAllocationType, fdwProtect, name));
     690
     691  if (cbSize > 0x7fc00000)  /* 2Gb - 4Mb */
     692  {
     693        dprintf(("VirtualAllocShared: size too large"));
     694        SetLastError( ERROR_OUTOFMEMORY );
     695        return NULL;
     696  }
     697
     698  if (!(fdwAllocationType & (MEM_COMMIT | MEM_RESERVE)) ||
     699       (fdwAllocationType & ~(MEM_COMMIT | MEM_RESERVE)))
     700  {
     701        dprintf(("VirtualAllocShared: Invalid parameter"));
     702        SetLastError( ERROR_INVALID_PARAMETER );
     703        return NULL;
     704  }
     705
     706  if(fdwAllocationType & MEM_COMMIT)
     707  {
     708        dprintf(("VirtualAllocShared: commit\n"));
     709        flag = PAG_COMMIT;
     710  }
     711
     712  if(fdwProtect & PAGE_READONLY)     flag |= PAG_READ;
     713  if(fdwProtect & PAGE_NOACCESS)     flag |= PAG_READ; //can't do this in OS/2
     714  if(fdwProtect & PAGE_READWRITE)    flag |= (PAG_READ | PAG_WRITE);
     715  if(fdwProtect & PAGE_WRITECOPY)    flag |= (PAG_READ | PAG_WRITE);
     716
     717  if(fdwProtect & PAGE_EXECUTE_READWRITE) flag |= (PAG_EXECUTE | PAG_WRITE | PAG_READ);
     718  if(fdwProtect & PAGE_EXECUTE_READ) flag |= (PAG_EXECUTE | PAG_READ);
     719  if(fdwProtect & PAGE_EXECUTE)      flag |= PAG_EXECUTE;
     720
     721  if(fdwProtect & PAGE_GUARD) {
     722        dprintf(("ERROR: PAGE_GUARD bit set for VirtualAllocShared -> we don't support this right now!"));
     723        flag |= PAG_GUARD;
     724  }
     725
     726  //just do this if other options are used
     727  if(!(flag & (PAG_READ | PAG_WRITE | PAG_EXECUTE)) || flag == 0)
     728  {
     729    dprintf(("VirtualAllocShared: Unknown protection flags, default to read/write"));
     730    flag |= PAG_READ | PAG_WRITE;
     731  }
     732
     733  rc = OSLibDosAllocSharedMem(&Address, cbSize, flag, name);
     734
     735  if(rc)
     736  {
     737    dprintf(("DosAllocSharedMem returned %d\n", rc));
     738    SetLastError( ERROR_OUTOFMEMORY );
     739    return(NULL);
     740  }
     741
     742  dprintf(("VirtualAllocShared returned %X\n", Address));
     743  return(Address);
     744}

  • trunk/src/kernel32/vmutex.cpp

    r730 r1432  
    1 /* $Id: vmutex.cpp,v 1.6 1999-08-28 19:33:44 sandervl Exp $ */
     1/* $Id: vmutex.cpp,v 1.7 1999-10-24 22:51:22 sandervl Exp $ */
    22
    33/*
    … …  
    2222 APIRET rc;
    2323
    24   rc = DosCreateMutexSem(NULL, &sem_handle, (fShared) ? DC_SEM_SHARED : 0, FALSE);
     24  rc = DosCreateMutexSem(NULL, &sem_handle, (fShared == VMUTEX_SHARED) ? DC_SEM_SHARED : 0, FALSE);
    2525  if(rc != 0) {
    2626    dprintf(("Error creating mutex %X\n", rc));
Note: See TracChangeset for help on using the changeset viewer.