Changeset 3059

Timestamp:

Mar 9, 2000, 8:03:23 PM (25 years ago)

Author:

sandervl

Message:

Dll dependency changes

Location:

trunk/src/kernel32

Files:

• KERNEL32.DEF (modified) (2 diffs)
• dbglocal.cpp (modified) (2 diffs)
• dbglocal.h (modified) (2 diffs)
• initterm.cpp (modified) (3 diffs)
• makefile (modified) (3 diffs)
• misc.cpp (modified) (2 diffs)
• mmap.cpp (modified) (6 diffs)
• queue.cpp (added)
• queue.h (added)
• windllbase.cpp (modified) (17 diffs)
• windllbase.h (added)
• windlllx.cpp (modified) (7 diffs)
• windlllx.h (added)
• windllpe2lx.cpp (modified) (2 diffs)
• winexebase.cpp (modified) (2 diffs)
• winexebase.h (added)
• winexepe2lx.cpp (modified) (3 diffs)
• winexepe2lx.h (added)
• winimagebase.cpp (modified) (2 diffs)
• winimagebase.h (added)
• winimagepeldr.cpp (modified) (4 diffs)
• wprocess.cpp (modified) (8 diffs)

trunk/src/kernel32/KERNEL32.DEF ¶

@@ -1 @@
-; $Id: KERNEL32.DEF,v 1.72 2000-03-03 11:15:58 sandervl Exp $
+; $Id: KERNEL32.DEF,v 1.73 2000-03-09 19:03:19 sandervl Exp $
 
 ;Created by BLAST for IBM's compiler
@@ -20 +20 @@
    DosQuerySysState            =  DOSCALLS.368
   _DosQuerySysState            =  DOSCALLS.368
-
-  _O32_RegCloseKey             = PMWINX.541
-  _O32_RegCreateKeyEx          = PMWINX.543
-  _O32_RegOpenKeyEx            = PMWINX.550
-  _O32_RegQueryValueEx         = PMWINX.553
-  _O32_RegSetValueEx           = PMWINX.555
-
-
 
 EXPORTS

trunk/src/kernel32/dbglocal.cpp ¶

@@ -1 @@
-/* $Id: dbglocal.cpp,v 1.2 2000-02-22 19:12:52 sandervl Exp $ */
+/* $Id: dbglocal.cpp,v 1.3 2000-03-09 19:03:18 sandervl Exp $ */
 
 /*
@@ -110 +110 @@
 "codepage",
 "debug",
-"oslibdebug"
+"oslibdebug",
+"registry",
+"queue"
 };
 //******************************************************************************

trunk/src/kernel32/dbglocal.h ¶

@@ -1 @@
-/* $Id: dbglocal.h,v 1.2 2000-02-22 19:12:53 sandervl Exp $ */
+/* $Id: dbglocal.h,v 1.3 2000-03-09 19:03:18 sandervl Exp $ */
 
 /*
@@ -111 +111 @@
 #define DBG_debug          90
 #define DBG_oslibdebug     91
-#define DBG_MAXFILES       92
+#define DBG_registry       92
+#define DBG_queue          93
+#define DBG_MAXFILES       94
 
 extern USHORT DbgEnabled[DBG_MAXFILES];

trunk/src/kernel32/initterm.cpp ¶

@@ -1 @@
-/* $Id: initterm.cpp,v 1.36 2000-03-03 11:15:58 sandervl Exp $ */
+/* $Id: initterm.cpp,v 1.37 2000-03-09 19:03:18 sandervl Exp $ */
 
 /*
@@ -47 +47 @@
 #include "hmdevio.h"
 #include <windllbase.h>
+#include "winexepe2lx.h"
 #include "initsystem.h"
 #include <exitlist.h>
@@ -128 +129 @@
                 return 0UL;
 
+            //SvL: Kernel32 is a special case; pe.exe loads it, so increase
+            //     the reference count here
+            Win32DllBase *module = Win32DllBase::findModule(hModule);
+            if(module && !fPe2Lx) {
+                module->AddRef();
+                module->DisableUnload();
+            }
+
             /*******************************************************************/
             /* A DosExitList routine must be used to clean up if runtime calls */

trunk/src/kernel32/makefile ¶

@@ -1 @@
-# $Id: makefile,v 1.89 2000-03-07 11:08:01 bird Exp $
+# $Id: makefile,v 1.90 2000-03-09 19:03:19 sandervl Exp $
 
 #
@@ -117 +117 @@
 $(OBJDIR)\dbglocal.obj \
 $(OBJDIR)\registry.obj \
+$(OBJDIR)\queue.obj \
 $(OBJDIR)\kernelrsrc.obj
 
@@ -160 +161 @@
 # Dep rule - makes depenencies for C, C++ and Asm files.
 dep:
-    $(DEPEND) -I$(PDWIN32_INCLUDE);$(PDWIN32_INCLUDE)\win \
+    $(DEPEND) -I. -I$(PDWIN32_INCLUDE);$(PDWIN32_INCLUDE)\win \
         *.c *.cpp *.h *.asm *.inc $(PDWIN32_INCLUDE)\*.h
 

trunk/src/kernel32/misc.cpp ¶

@@ -1 @@
-/* $Id: misc.cpp,v 1.19 2000-01-25 21:00:39 sandervl Exp $ */
+/* $Id: misc.cpp,v 1.20 2000-03-09 19:03:19 sandervl Exp $ */
 
 /*
@@ -316 +316 @@
 
     va_start(argptr, tekst);
-    if(thdb) { 
-        thdb->logfile = (DWORD)flog;
-        fprintf(flog, "t%d", thdb->threadId);
-    }
     vfprintf((FILE *)logfile, tekst, argptr);
     if(thdb) thdb->logfile = 0;

trunk/src/kernel32/mmap.cpp ¶

@@ -1 @@
-/* $Id: mmap.cpp,v 1.35 2000-03-02 19:17:21 sandervl Exp $ */
+/* $Id: mmap.cpp,v 1.36 2000-03-09 19:03:19 sandervl Exp $ */
 
 /*
@@ -502 +502 @@
 }
 //******************************************************************************
-//Assumes mutex has been acquired
 //******************************************************************************
 void Win32MemMap::deleteAll()
@@ -510 +509 @@
 
   //delete all maps created by this process
+  globalviewMutex.enter();
   while(map) {
         nextmap = map->next;
@@ -525 +525 @@
         map = nextmap;
   }
+  globalviewMutex.leave();
 }
 //******************************************************************************
@@ -691 +692 @@
   Win32MemMapView *view = mapviews;
 
+  globalviewMutex.enter();
   if(view != NULL) {
         while(view) {
@@ -700 +702 @@
         }
   }
+  globalviewMutex.leave();
   return view;
 }

trunk/src/kernel32/windllbase.cpp ¶

@@ -1 @@
-/* $Id: windllbase.cpp,v 1.10 2000-03-04 19:52:36 sandervl Exp $ */
+/* $Id: windllbase.cpp,v 1.11 2000-03-09 19:03:20 sandervl Exp $ */
 
 /*
@@ -6 +6 @@
  * Copyright 1998-1999 Sander van Leeuwen (sandervl@xs4all.nl)
  *
- * TODO: Unloading of system dlls is not correct for the PE loader
- *       (they're always put at the head of the list even though there
- *        might be a dependency with a win32 dll)
+ * Unloading of a dll always happens in order of dependency (taking nr of
+ * loads into account)
+ * Unloading of dynamically loaded dll (with LoadLibrary) in deleteAll
+ * is done in LIFO order (NT exhibits the same behaviour)
+ *           
+ * RemoveCircularDependency: TODO: Send process detach message here??
  *
  * Project Odin Software License can be found in LICENSE.TXT
@@ -26 +29 @@
 #include <fstream.h>
 #include <misc.h>
-#include <win32type.h>
+#include <win32api.h>
 #include <pefile.h>
 #include <windllbase.h>
@@ -48 +51 @@
                            Win32ImageBase *parent)
                  : Win32ImageBase(hinstance),
-                   referenced(0), fSkipEntryCalls(FALSE),
-                   fAttachedToProcess(FALSE), fUnloaded(FALSE), fDynamicLoad(FALSE)
+                   referenced(0), fSkipEntryCalls(FALSE), next(NULL), fInserted(FALSE),
+                   fAttachedToProcess(FALSE), fUnloaded(FALSE), 
+                   nrDynamicLibRef(0), fLoadLibrary(FALSE), fDisableUnload(FALSE)
 {
   dllEntryPoint = DllEntryPoint;
 
-  dlllistmutex.enter();
-  //unload of dlls needs to be done in reverse order of dependencies
-  //Note: Only necessary for pe loader; the OS/2 loader takes care of this 
-  //for win32k/pe2lx 
-  if(parent && parent->isDll()) {
-        Win32DllBase *dll = head;
-        while(dll) {
-                if(dll->getInstanceHandle() == parent->getInstanceHandle()) {
-                        break;
-                }
-                dll = dll->next;
-        }
-        if(dll) {
-                //insert this dll in list after it's parent
-                next = dll->next;
-                dll->next = this;
-        }
-        else    DebugInt3();
-  }
-  else {
-        next = head;
-        head = this;
-  }
-  dlllistmutex.leave();
-
-#ifdef DEBUG_ENABLELOG_LEVEL2
-  dlllistmutex.enter();
-  Win32DllBase *dll = head;
-
-  dprintf2(("Win32DllBase::Win32DllBase: List of loaded dlls:"));
-  while(dll) {
-        dprintf2(("DLL %s", dll->szModule));
-        dll = dll->next;
-  }
-  dlllistmutex.leave();
-#endif
-
+  setUnloadOrder(parent);
+  
   dprintf(("Win32DllBase::Win32DllBase %x %s", hinstance, szModule));
 }
@@ -122 +91 @@
 }
 //******************************************************************************
-//ASSUMPTION: called by FreeLibrary
+//******************************************************************************
+void Win32DllBase::loadLibrary()
+{
+  //dummy
+}
+//******************************************************************************
+//******************************************************************************
+void Win32DllBase::incDynamicLib()
+{ 
+  if(nrDynamicLibRef == 0) {
+        dlllistmutex.enter();
+        loadLibDlls.Push((ULONG)this);
+        dlllistmutex.leave();
+  }
+  nrDynamicLibRef++; 
+}
+//******************************************************************************
+//******************************************************************************
+void Win32DllBase::decDynamicLib()
+{ 
+  nrDynamicLibRef--; 
+  if(nrDynamicLibRef == 0) {
+        dlllistmutex.enter();
+        loadLibDlls.Remove((ULONG)this);
+        dlllistmutex.leave();
+  }
+}
+//******************************************************************************
+//unload of dlls needs to be done in reverse order of dependencies
+//Note: Only necessary for pe loader; the OS/2 loader takes care of this 
+//for win32k/pe2lx 
+//******************************************************************************
+void Win32DllBase::setUnloadOrder(Win32ImageBase *parent)
+{
+ Win32DllBase *dll;
+ Win32DllBase *parentdll = NULL;
+
+  dlllistmutex.enter();
+  if(parent) {
+        dll = head;
+        while(dll) {
+                if(dll->getInstanceHandle() == parent->getInstanceHandle()) {
+                        parentdll = dll;
+                        break;
+                }
+                dll = dll->next;
+        }
+  }
+
+  //first check if this dll is already at a lower position (further down the list)
+  //than the parent
+  if(parentdll && fInserted) {//already in the list?
+        dll = parentdll->next;
+        while(dll) {
+                if(dll->getInstanceHandle() == getInstanceHandle()) {
+                        dlllistmutex.leave();
+                        return; //it's at a lower position, so no need to change anything
+                }
+                dll = dll->next;
+        }
+
+        //it's already in the list but not at the right position; remove it now
+        if(head == this) {
+                head = next;
+        }
+        else {
+                dll = head;
+                while(dll->next) {
+                        if(dll->next == this) {
+                                dll->next = next;
+                                break;
+                        }
+                        dll = dll->next;
+                }
+        }
+  }
+  else 
+  if(fInserted) {//already in the list?
+        dlllistmutex.leave();
+        return;
+  }
+  //(re)insert it in the list after it's parent
+  if(parentdll) {
+        next = parentdll->next;
+        parentdll->next = this;
+  }
+  else {//no parent or exe, just add it at the start of the list
+        next = head;
+        head = this;
+  }
+  fInserted = TRUE;
+
+  //Now do the same thing for the child dependencies
+  QueueItem *item;
+
+  item = loadedDlls.Head();
+  while(item) {
+        dll = (Win32DllBase *)loadedDlls.getItem(item);
+        //Check for circular dependencies (i.e. in Lotus Notes)
+        if(dll != parentdll) {
+                dll->setUnloadOrder(this);
+        }
+
+        item  = loadedDlls.getNext(item);
+  }
+
+  dlllistmutex.leave();
+}
+//******************************************************************************
+//******************************************************************************
+#ifdef DEBUG
+ULONG Win32DllBase::AddRef(char *parentname)
+#else
+ULONG Win32DllBase::AddRef()
+#endif
+{ 
+ Win32DllBase *dll;
+
+  dprintf(("Win32DllBase::AddRef %s->%s %d", parentname, getModuleName(), referenced+1));
+  ++referenced;
+#ifdef DEBUG
+  if(referenced == 1) {
+#ifdef DEBUG_ENABLELOG_LEVEL2
+        printListOfDlls();
+#endif
+        //printDependencies(NULL);
+  }
+#endif
+
+  return referenced; 
+}
+//******************************************************************************
 //******************************************************************************
 ULONG Win32DllBase::Release()
 {
- ULONG ret = --referenced;
-
-  if(ret == 0) {
-        dprintf(("Win32DllBase::Release, referenced == 0\n"));
+ Queue         queue;
+ QueueItem    *item;
+ Win32DllBase *dll;
+ LONG          ret;
+
+  dprintf(("Win32DllBase::Release %s %d", getModuleName(), referenced-1));
+
+  ret = --referenced;
+  if(ret <= 0) {
+        //make copy of linked list of dependencies
+        queue = loadedDlls;
+
+        //remove any circular dependencies on this dll that might be present
+        item = queue.Head();
+        while(item) {
+                dll = (Win32DllBase *)queue.getItem(item);
+                if(dll == NULL) {
+                        dprintf(("ERROR: Win32DllBase::Release: dll item == NULL!!"));
+                        DebugInt3();
+                        return -1;
+                }
+                dll->RemoveCircularDependency(this);
+                item = queue.getNext(item);
+        }
+#ifdef DEBUG
+        //printDependencies(NULL);
+#endif
+        dprintf(("Win32DllBase::Release %s referenced == 0", getModuleName()));
+
+        //delete dll object
         delete this;
+
+        //unreference all of it's dependencies
+        item = queue.Head();
+        while(item) {
+                dll = (Win32DllBase *)queue.getItem(item);
+                if(dll == NULL) {
+                        dprintf(("ERROR: Win32DllBase::Release: dll item == NULL!!"));
+                        DebugInt3();
+                        return -1;
+                }
+                dll->Release();
+                item = queue.getNext(item);
+        }
   }
   return(ret);
 }
+//******************************************************************************
+//Lotus Notes has several ugly circular dependencies in it's dlls.
+//Remove them before they cause problems.
+//******************************************************************************
+BOOL Win32DllBase::RemoveCircularDependency(Win32DllBase *parent)
+{
+ QueueItem    *item, *tmp;
+ Win32DllBase *dll;
+ BOOL          ret = FALSE;
+
+  //remove any circular dependencies on this dll that might be present
+  item = loadedDlls.Head();
+  while(item) {
+        dll = (Win32DllBase *)loadedDlls.getItem(item);
+        if(dll == NULL) {
+                dprintf(("ERROR: Win32DllBase::Release: dll item == NULL!!"));
+                DebugInt3();
+                return FALSE;
+        }
+        tmp = loadedDlls.getNext(item);
+        if(dll == parent) {
+                dprintf(("Removing CIRCULAR dependency %s->%s", parent->getModuleName(), dll->getModuleName()));
+                loadedDlls.Remove(item);
+                ret = TRUE;
+        }
+////    else    ret |= dll->RemoveCircularDependency(parent);
+        item = tmp;
+  }
+  //TODO: Send process detach message here??
+  return ret;
+}
+//******************************************************************************
+//There's a slight problem with our dependency procedure. 
+//example: gdi32 is loaded -> depends on kernel32 (which is already loaded)
+//         kernel32's reference count isn't updated
+//         (when we load gdi32, we don't know which dlls it depends on and which
+//          of those are already loaded and which aren't)
+//-> solution: Determine reference counts of dependant lx dlls and update those
+//             reference counts
+//******************************************************************************
+void Win32DllBase::updateDependencies()
+{
+ QueueItem    *item;
+ Win32DllBase *dll, *depdll;
+ ULONG         refcount;
+ 
+  dlllistmutex.enter();
+  item = loadedDlls.Head();
+  while(item) {
+        depdll   = (Win32DllBase *)loadedDlls.getItem(item);
+        if(depdll == NULL) {
+                dprintf(("updateDependencies: depdll == NULL!!"));
+                DebugInt3();    
+                return;
+        }
+        refcount = 0;
+        dll      = head;
+
+        while(dll) {
+                if(dll->dependsOn(depdll)) {
+                        refcount++;
+                }
+                dll = dll->getNext();
+        }
+        if(refcount > depdll->referenced) {
+                dprintf(("Win32DllBase::updateDependencies changing refcount of %s to %d (old=%d)", depdll->getModuleName(), refcount, depdll->referenced));
+                depdll->referenced = refcount;
+        }
+
+        item = loadedDlls.getNext(item);
+  }
+  dlllistmutex.leave();
+}
+//******************************************************************************
+//******************************************************************************
+#ifdef DEBUG
+void Win32DllBase::printDependencies(char *parent)
+{
+ QueueItem    *item;
+ Win32DllBase *dll;
+ ULONG         ret;
+
+  dprintf(("Dependency list: %s->%s %d", parent, getModuleName(), referenced));
+  item = loadedDlls.Head();
+  while(item) {
+        dll = (Win32DllBase *)loadedDlls.getItem(item);
+        if(dll == NULL) {
+                return;
+        }
+        dll->printDependencies(getModuleName());
+        item = loadedDlls.getNext(item);
+  }
+}
+//******************************************************************************
+//******************************************************************************
+#ifdef DEBUG_ENABLELOG_LEVEL2
+void Win32DllBase::printListOfDlls()
+{
+ Win32DllBase *dll;
+
+  dll = head;
+
+  dprintf2(("Win32DllBase::Win32DllBase: List of loaded dlls:"));
+  while(dll) {
+        dprintf2(("DLL %s %d", dll->szModule, dll->referenced));
+        dll = dll->next;
+  }
+}
+#endif
+#endif
 //******************************************************************************
 //******************************************************************************
@@ -252 +501 @@
 void Win32DllBase::attachThreadToAllDlls()
 {
+  dlllistmutex.enter();
   Win32DllBase *dll = Win32DllBase::head;
   while(dll) {
@@ -257 +507 @@
         dll = dll->getNext();
   }
+  dlllistmutex.leave();
 }
 //******************************************************************************
@@ -263 +514 @@
 void Win32DllBase::detachThreadFromAllDlls()
 {
+  dlllistmutex.enter();
   Win32DllBase *dll = Win32DllBase::head;
   while(dll) {
@@ -268 +520 @@
         dll = dll->getNext();
   }
+  dlllistmutex.leave();
 }
 //******************************************************************************
@@ -274 +527 @@
 void Win32DllBase::tlsAttachThreadToAllDlls()
 {
+  dlllistmutex.enter();
   Win32DllBase *dll = Win32DllBase::head;
   while(dll) {
@@ -279 +533 @@
         dll = dll->getNext();
   }
+  dlllistmutex.leave();
 }
 //******************************************************************************
@@ -285 +540 @@
 void Win32DllBase::tlsDetachThreadFromAllDlls()
 {
+  dlllistmutex.enter();
   Win32DllBase *dll = Win32DllBase::head;
   while(dll) {
@@ -290 +546 @@
         dll = dll->getNext();
   }
-}
-//******************************************************************************
-//******************************************************************************
-void Win32DllBase::deleteAll(BOOL fDynamicLoad)
-{
- Win32DllBase *dll = Win32DllBase::head, *tmp;
-
-#ifdef DEBUG
-  dlllistmutex.enter();
-
-  dprintf(("Win32DllBase::deleteAll: List of loaded dlls:"));
+  dlllistmutex.leave();
+}
+//******************************************************************************
+//******************************************************************************
+void Win32DllBase::deleteAll()
+{
+ Win32DllBase *dll = Win32DllBase::head;
+
+  dprintf(("Win32DllBase::deleteAll"));
+
+#ifdef DEBUG_ENABLELOG_LEVEL2
+  if(dll) dll->printListOfDlls();
+#endif
+
+  dlllistmutex.enter();
   while(dll) {
-        dprintf(("DLL %s", dll->szModule));
-        dll = dll->next;
-  }
-  dlllistmutex.leave();
-  dll = Win32DllBase::head;
+        dll->Release();
+        dll = Win32DllBase::head;
+  }
+  dlllistmutex.leave();
+  dprintf(("Win32DllBase::deleteAll Done!"));
+}
+//******************************************************************************
+//Delete dlls loaded by LoadLibrary(Ex) in LIFO order
+//******************************************************************************
+void Win32DllBase::deleteDynamicLibs()
+{
+ Win32DllBase *dll = head;
+ QueueItem    *item;
+
+  dprintf(("Win32DllBase::deleteDynamicLibs"));
+#ifdef DEBUG_ENABLELOG_LEVEL2
+  if(dll) dll->printListOfDlls();
 #endif
 
-  while(dll) {
-        if(fDynamicLoad || !dll->fDynamicLoad) {
-                tmp = dll->next;
-                dll->Release();
-                dll = tmp;
-        }
-        else    dll = dll->next;
-  }
+  dlllistmutex.enter();
+
+  item = loadLibDlls.Head();
+  while(item) {
+        dll = (Win32DllBase *)loadLibDlls.getItem(item);
+        int dynref = dll->nrDynamicLibRef;
+        if(dynref) {
+                while(dynref) {
+                        dynref--;
+                        dll->decDynamicLib();
+                        dll->Release();
+                }
+        }
+        else    DebugInt3();
+        item = loadLibDlls.Head(); //queue could have been changed, so start from the beginning
+  }
+
+  dlllistmutex.leave();
+}
+//******************************************************************************
+//******************************************************************************
+Win32DllBase *Win32DllBase::getFirst()
+{
+  return head;
 }
 //******************************************************************************
@@ -386 +674 @@
 //******************************************************************************
 //******************************************************************************
-Win32DllBase *Win32DllBase::findModule(char *dllname)
+Win32DllBase *Win32DllBase::findModule(char *dllname, BOOL fRenameFirst)
 {
  Win32DllBase *dll;
@@ -392 +680 @@
  char *dot, *temp;
 
-  dprintf(("findModule %s", dllname));
+////  dprintf2(("findModule %s", dllname));
 
   strcpy(szDllName, OSLibStripPath(dllname));
   strupr(szDllName);
+
+  if(fRenameFirst) {
+        renameDll(szDllName, FALSE);
+  }
+
   dot = strstr(szDllName, ".");
   if(dot)
@@ -417 +710 @@
 Win32DllBase *Win32DllBase::findModule(WIN32DLLENTRY DllEntryPoint)
 {
-   dprintf(("findModule %X", DllEntryPoint));
+   dprintf2(("findModule %X", DllEntryPoint));
 
    dlllistmutex.enter();
@@ -468 +761 @@
 //******************************************************************************
 Win32DllBase *Win32DllBase::head = NULL;
+Queue         Win32DllBase::loadLibDlls;

trunk/src/kernel32/windlllx.cpp ¶

@@ -1 @@
-/* $Id: windlllx.cpp,v 1.8 2000-02-16 14:22:11 sandervl Exp $ */
+/* $Id: windlllx.cpp,v 1.9 2000-03-09 19:03:21 sandervl Exp $ */
 
 /*
  * Win32 LX Dll class (compiled in OS/2 using Odin32 api)
  *
- * Copyright 1999 Sander van Leeuwen (sandervl@xs4all.nl)
- *
+ * Copyright 1999-2000 Sander van Leeuwen (sandervl@xs4all.nl)
  *
  * TODO: Unloading of dlls probably needs to be fixed due to OS/2 bug 
  *       (wrong unload order of dlls)
- * TODO: Unloading of system dlls is not correct for the PE loader
- *       (they're always put at the head of the list even though there
- *        might be a dependency with a win32 dll)
  *
  * Project Odin Software License can be found in LICENSE.TXT
@@ -23 +19 @@
 #define INCL_WIN
 #include <os2wrap.h>    //Odin32 OS/2 api wrappers
+#include <os2newapi.h>
 #include <stdio.h>
 #include <string.h>
@@ -32 +29 @@
 #include <windllbase.h>
 #include <windlllx.h>
+#include "winexepe2lx.h"
 #include <odinlx.h>
 #include "oslibmisc.h"
+
+#include <exe386.h>
 
 #define DBG_LOCALLOG    DBG_windlllx
@@ -47 +47 @@
 {
  Win32LxDll *windll;
+ Win32DllBase *windlldep;
 
    windll = (Win32LxDll *)Win32DllBase::findModule(hInstance);
@@ -59 +60 @@
         return FALSE;
    }
-   windll->AddRef();
-   if(windll->attachProcess() == 0)
-        return 0;
-
+   if(fPe2Lx) {
+        windll->AddRef();
+
+        if(windll->attachProcess() == 0)
+                return 0;
+
+        return windll->getInstanceHandle();
+   }
+   IMAGE_DOS_HEADER doshdr;
+   struct e32_exe   lxhdr;
+   ULONG            offset;
+   char             modulename[CCHMAXPATH];
+   char             modsize;
+   APIRET           rc;
+   int              i;
+
+   //SvL: This code reads the import name table of the dll to get the dependencies
+   //     on other dlls.
+   //DosQueryHeaderInfo is an undocumented api, but works very well.
+   //(no need to save FS here as we'll return to OS/2 immediately)
+   rc = DosQueryHeaderInfo(hInstance, 0, &doshdr, sizeof(IMAGE_DOS_HEADER), QHINF_READFILE);
+   if(rc) {
+        goto hdrerror;
+   }
+   rc = DosQueryHeaderInfo(hInstance, doshdr.e_lfanew, &lxhdr, sizeof(e32_exe), QHINF_READFILE);
+   if(rc) {
+        goto hdrerror;
+   }
+   offset = doshdr.e_lfanew + lxhdr.e32_impmod;
+   for(i=0;i<lxhdr.e32_impmodcnt;i++) {
+        rc = DosQueryHeaderInfo(hInstance, offset, &modsize, 1, QHINF_READFILE);
+        if(rc) {
+                goto hdrerror;
+        }
+        rc = DosQueryHeaderInfo(hInstance, offset+1, &modulename, min(modsize, sizeof(modulename)), QHINF_READFILE);
+        if(rc) {
+                goto hdrerror;
+        }
+        modulename[modsize] = 0;
+        windlldep = Win32DllBase::findModule(modulename, TRUE);
+        if(windlldep) {
+                dprintf(("RegisterLxDll: Add dependency %s -> %s", windll->getModuleName(), modulename));
+                windll->addDependency(windlldep);
+        }
+        offset += modsize + 1;
+   }
    return windll->getInstanceHandle();
+
+hdrerror:
+   dprintf(("DosQueryHeaderInfo returned %d", rc));
+   return windll->getInstanceHandle();
 }
 //******************************************************************************
@@ -70 +117 @@
 BOOL WIN32API UnregisterLxDll(HINSTANCE hInstance)
 {
-#if 1
-   return TRUE;
-#else
  Win32LxDll *windll;
+
+   //Don't proceed for pe2lx/win32k (os/2 dll unload dependency bug)
+   //Don't do it either after ExitProcess has been called
+   if(fPe2Lx || WinExe == NULL)
+        return TRUE;
 
    windll = (Win32LxDll *)Win32DllBase::findModule(hInstance);
    if(!windll) {
-        dprintf(("UnregisterLxDll: Can't find dll with handle %x!!!", hInstance));
-        return FALSE;
-   }
-   windll->detachProcess();
+        dprintf(("UnregisterLxDll: Can't find dll with handle %x (already deleted)", hInstance));
+        return TRUE; //already deleted by Win32LxDll::Release
+   }
+   dprintf(("UnregisterLxDll %s", windll->getModuleName()));
+   //This can only happen for LX dependencies (i.e. wininet loads wsock32)
    delete windll;
    return TRUE;
-#endif
 }
 //******************************************************************************
@@ -101 +150 @@
 Win32LxDll::~Win32LxDll()
 {
-  dprintf(("Win32LxDll::~Win32LxDll %s", szModule));
-}
-//******************************************************************************
-//ASSUMPTION: called by FreeLibrary
+}
+//******************************************************************************
+//Load it again so OS/2 takes care of the reference count (to make sure
+//a dll isn't unloaded when the win32 app still needs it)
+//******************************************************************************
+void Win32LxDll::loadLibrary()
+{
+ char   szModuleFailure[CCHMAXPATH] = "";
+ ULONG  hInstanceNewDll;
+ APIRET rc;
+
+  if(fLoadLibrary) {
+        DebugInt3();
+        return;
+  }
+
+  dprintf(("Win32LxDll::loadLibrary %s", getModuleName()));
+  rc = DosLoadModule(szModuleFailure, sizeof(szModuleFailure), getFullPath(), (HMODULE *)&hInstanceNewDll);
+  if(rc) {
+        dprintf(("DosLoadModule returned %X for %s\n", rc, szModuleFailure));
+        DebugInt3(); //should NEVER happen
+        return;
+  }
+  //only do this once, so set the fLoadLibrary flag to true
+  setLoadLibrary();
+}
+//******************************************************************************
+//******************************************************************************
+#ifdef DEBUG
+ULONG Win32LxDll::AddRef(char *parentname)
+#else
+ULONG Win32LxDll::AddRef()
+#endif
+{
+ Win32DllBase *dll;
+ QueueItem    *item;
+ ULONG         ret;
+
+#ifdef DEBUG
+  ret = Win32DllBase::AddRef(parentname);
+#else
+  ret = Win32DllBase::AddRef();
+#endif
+
+  if(fPe2Lx)
+        return ret;
+
+  if(referenced == 1) 
+  {
+        item = loadedDlls.Head();
+        while(item) {
+                dll = (Win32DllBase *)loadedDlls.getItem(item);
+                if(dll == NULL) {
+                        dprintf(("ERROR: Win32DllBase::AddRef: dll item == NULL!!"));
+                        DebugInt3();
+                        return -1;
+                }
+#ifdef DEBUG
+                dll->AddRef(getModuleName());
+#else
+                dll->AddRef();
+#endif
+                item = loadedDlls.getNext(item);
+        }
+        if(attachProcess() == 0)
+                return 0;
+  }
+  return ret;  
+}
+//******************************************************************************
 //******************************************************************************
 ULONG Win32LxDll::Release()
 { 
- ULONG ret = --referenced;
  HINSTANCE hinst;
-
-  if(ret == 0) {
-        dprintf(("Win32LxDll::Release, referenced == 0\n"));
+ ULONG     ret;
+ APIRET    rc;
+ BOOL      fLoadLib = fLoadLibrary;
+
+  if(fDisableUnload) {//only set for kernel32.dll
+        fLoadLib = FALSE;
+  }
+  hinst = hinstance;
+  ret = Win32DllBase::Release();
+  if(ret == 0 && fLoadLib) {
         //DosFreeModule sends a termination message to the dll.
         //The LX dll informs us when it's removed (UnregisterDll call)
-        hinst = hinstance;
-        delete this;
-        DosFreeModule(hinst);
+        rc = DosFreeModule(hinst);
+        if(rc) {
+                dprintf(("Win32LxDll::Release: DosFreeModule %x returned %d", hinst, rc));
+        }
   }
   return(ret);

trunk/src/kernel32/windllpe2lx.cpp ¶

@@ -1 @@
-/* $Id: windllpe2lx.cpp,v 1.6 2000-02-16 14:22:11 sandervl Exp $ */
+/* $Id: windllpe2lx.cpp,v 1.7 2000-03-09 19:03:21 sandervl Exp $ */
 
 /*
@@ -16 +16 @@
 #define INCL_DOSERRORS      /* DOS Error values */
 #define INCL_DOSMODULEMGR   /* DOS Module management */
-
+#define INCL_DOSSEMAPHORES
 
 /*******************************************************************************

trunk/src/kernel32/winexebase.cpp ¶

@@ -1 @@
-/* $Id: winexebase.cpp,v 1.6 2000-03-04 19:52:36 sandervl Exp $ */
+/* $Id: winexebase.cpp,v 1.7 2000-03-09 19:03:21 sandervl Exp $ */
 
 /*
@@ -59 +59 @@
 Win32ExeBase::~Win32ExeBase()
 {
-  //First delete all dlls that were loaded by the exe or dlls
-  //Then delete all dlls loaded by LoadLibrary (to avoid that we
-  //delete some dlls before the dll, that loaded it, is destroyed)
+ QueueItem    *item;
+ Win32DllBase *dll;
+
+  //First delete all dlls loaded by LoadLibrary 
+  //Then delete all dlls that were loaded by the exe
+  //(NOTE: This is what NT does; first delete loadlib dlls in LIFO order and
+  //       then the exe dlls)
+  Win32DllBase::deleteDynamicLibs();
+
+  dprintf(("Win32ExeBase::~Win32ExeBase"));
+#ifdef DEBUG_ENABLELOG_LEVEL2
+  item = loadedDlls.Head();
+  dll = (Win32DllBase *)loadedDlls.getItem(item);
+  dll->printListOfDlls();
+#endif
+
+  item = loadedDlls.Head();
+  while(item) {
+        dll = (Win32DllBase *)loadedDlls.getItem(item);
+        if(dll == NULL) {
+                dprintf(("ERROR: Win32ExeBase::~Win32ExeBase: dll item == NULL!!"));
+                DebugInt3();
+                break;
+        }
+        dll->Release();
+        item = loadedDlls.getNext(item);
+  }
+
   Win32DllBase::deleteAll();
-  Win32DllBase::deleteAll(TRUE);
 
   WinExe = NULL;

trunk/src/kernel32/winexepe2lx.cpp ¶

@@ -1 @@
-/* $Id: winexepe2lx.cpp,v 1.4 2000-02-16 14:22:11 sandervl Exp $ */
+/* $Id: winexepe2lx.cpp,v 1.5 2000-03-09 19:03:22 sandervl Exp $ */
 
 /*
@@ -37 +37 @@
 
 
+BOOL fPe2Lx = FALSE;
+
 /**
  * Register a Pe2Lx Executable module.
@@ -56 +58 @@
 {
     Win32Pe2LxExe *pWinPe2LxExe;
+
+    fPe2Lx = TRUE;
 
     /* I/O init. */

trunk/src/kernel32/winimagebase.cpp ¶

@@ -1 @@
-/* $Id: winimagebase.cpp,v 1.9 2000-02-22 19:12:53 sandervl Exp $ */
+/* $Id: winimagebase.cpp,v 1.10 2000-03-09 19:03:22 sandervl Exp $ */
 
 /*
@@ -98 +98 @@
 }
 //******************************************************************************
+//Add image to dependency list of this image
+//******************************************************************************
+void Win32ImageBase::addDependency(Win32DllBase *image)
+{
+  loadedDlls.Push((ULONG)image);
+}
+//******************************************************************************
+//******************************************************************************
+BOOL Win32ImageBase::dependsOn(Win32DllBase *image)
+{
+ QueueItem    *item;
+ BOOL          ret = FALSE;
+
+  dlllistmutex.enter();
+  item = loadedDlls.Head();
+  while(item) {
+        if(loadedDlls.getItem(item) == (ULONG)image) {
+                ret = TRUE;
+                break;
+        }         
+        item = loadedDlls.getNext(item);
+  }
+  dlllistmutex.leave();
+  return ret;
+}
+//******************************************************************************
 //Returns required OS version for this image
 //******************************************************************************

trunk/src/kernel32/winimagepeldr.cpp ¶

@@ -1 @@
-/* $Id: winimagepeldr.cpp,v 1.34 2000-03-04 19:52:36 sandervl Exp $ */
+/* $Id: winimagepeldr.cpp,v 1.35 2000-03-09 19:03:22 sandervl Exp $ */
 
 /*
@@ -37 +37 @@
 #include <misc.h>
 #include <win32api.h>
-#include <winimagebase.h>
-#include <winimagepeldr.h>
-#include <windllpeldr.h>
+#include "winimagebase.h"
+#include "winimagepeldr.h"
+#include "windllpeldr.h"
 #include <pefile.h>
 #include <unicode.h>
@@ -1389 +1389 @@
                         return(FALSE);
                 }
+                //Mark this dll as loaded by DosLoadModule
+                WinDll->setLoadLibrary();
+                WinDll->AddRef();
         }
         else {
@@ -1406 +1409 @@
                     return(FALSE);
                 }
+#ifdef DEBUG
+                WinDll->AddRef(getModuleName());
+#else
+                WinDll->AddRef();
+#endif
                 if(WinDll->attachProcess() == FALSE) {
                     dprintf((LOG, "attachProcess failed!" ));
+                    delete WinDll;
                     errorState = ERROR_INTERNAL;
                     return(FALSE);
                 }
         }
+
         dprintf((LOG, "**********************************************************************" ));
         dprintf((LOG, "**********************  Finished Loading Module  *********************" ));
         dprintf((LOG, "**********************************************************************" ));
     }
-    else    dprintf((LOG, "Already found ", pszCurModule ));
-
-    WinDll->AddRef();
+    else {
+        if(WinDll->isLxDll() && !WinDll->isLoaded()) {
+                //can happen with i.e. wininet
+                //wininet depends on wsock32; when the app loads wsock32 afterwards
+                //with LoadLibrary or as a child of another dll, we need to make
+                //sure it's loaded once with DosLoadModule
+                WinDll->loadLibrary();
+        }
+        WinDll->AddRef();
+        
+        dprintf((LOG, "Already found ", pszCurModule));
+    }
+    //add the dll we just loaded to dependency list for this image
+    addDependency((Win32DllBase *)WinDll);
+
+    //Make sure the dependency list is correct (already done
+    //in the ctor of Win32DllBase, but for LX dlls the parent is
+    //then set to NULL; so change it here again
+    WinDll->setUnloadOrder(this);
 
     pulImport  = (PULONG)((ULONG)pulImport + (ULONG)win32file);

trunk/src/kernel32/wprocess.cpp ¶

@@ -1 @@
-/* $Id: wprocess.cpp,v 1.71 2000-03-04 19:52:37 sandervl Exp $ */
+/* $Id: wprocess.cpp,v 1.72 2000-03-09 19:03:23 sandervl Exp $ */
 
 /*
@@ -20 +20 @@
 
 #include <unicode.h>
-#include <windllbase.h>
-#include <winexebase.h>
-#include <windllpeldr.h>
-#include <winfakepeldr.h>
+#include "windllbase.h"
+#include "winexebase.h"
+#include "windllpeldr.h"
+#include "winexepe2lx.h"
+#include "winfakepeldr.h"
 #include <vmutex.h>
 
@@ -382 +383 @@
   if(winmod) {
         dprintf(("FreeLibrary %s", winmod->getName()));
-        winmod->Release();
+        //Only free it when the nrDynamicLibRef != 0
+        //This prevent problems after ExitProcess:
+        //i.e. dll A is referenced by our exe and loaded with LoadLibrary by dll B
+        //     During ExitProcess it's unloaded once (before dll B), dll B calls
+        //     FreeLibrary, but our exe also has a reference -> unloaded too many times
+        if(winmod->isDynamicLib()) {
+                winmod->decDynamicLib();
+                winmod->Release();
+        }
+        else {
+                dprintf(("Skipping dynamic unload as nrDynamicLibRef == 0"));
+        }
         return(TRUE);
   }
@@ -404 +416 @@
   module = Win32DllBase::findModule((LPSTR)lpszLibFile);
   if(module) {
+        if(module->isLxDll() && !module->isLoaded() && !fPe2Lx) {
+                //can happen with i.e. wininet
+                //wininet depends on wsock32; when the app loads wsock32 afterwards
+                //with LoadLibrary or as a child of another dll, we need to make
+                //sure it's loaded once with DosLoadModule
+                module->setLoadLibrary();
+        }
+        module->incDynamicLib();
         module->AddRef();
-    dprintf(("iLoadLibrary: found %s -> handle %x", lpszLibFile, module->getInstanceHandle()));
+        dprintf(("iLoadLibrary: found %s -> handle %x", lpszLibFile, module->getInstanceHandle()));
         return module->getInstanceHandle();
   }
@@ -421 +441 @@
   if(hDll)
   {
-    return hDll;    //converted dll or win32k took care of it
+        module = Win32DllBase::findModule(hDll);
+        if(module && module->isLxDll() && !fPe2Lx) {
+                module->setLoadLibrary();
+                module->AddRef();
+        }
+        if(module)
+                module->incDynamicLib();
+        //system dll, converted dll or win32k took care of it
+        return hDll;
   }
 
   if(!strstr(modname, ".")) {
-    strcat(modname,".DLL");
+        strcat(modname,".DLL");
   }
 
@@ -432 +460 @@
         module = Win32DllBase::findModule((char *)modname);
         if(module) {//don't load it again
+            module->incDynamicLib();
             module->AddRef();
             return module->getInstanceHandle();
@@ -449 +478 @@
             peldrDll->setNoEntryCalls();
         }
-        //Set flag so this dll doesn't get automatically deleted in ExitProcess
-        //(the first time); give application the chance to free it first
-        //If it's not freed, we delete it the 2nd time in ExitProcess
-        peldrDll->SetDynamicallyLoaded();
+        peldrDll->incDynamicLib();
+        peldrDll->AddRef();
 
         if(peldrDll->attachProcess() == FALSE) {
@@ -459 +486 @@
             return(0);
         }
-        peldrDll->AddRef();
         return peldrDll->getInstanceHandle();
   }