Changeset 2842 for trunk/kLdr/kLdrDyldMod.c

Timestamp:

Oct 30, 2006, 1:49:15 AM (19 years ago)

Author:

bird

Message:

toplevel load api code is done.

File:

• trunk/kLdr/kLdrDyldMod.c (modified) (1 diff)

trunk/kLdr/kLdrDyldMod.c

@@ -49 +49 @@
 
 
-
+/**
+ * Decrement the dynamic load count of the module and unload the module
+ * if the total reference count reaches zero.
+ *
+ * This may cause a cascade of unloading to occure. See kldrDyldModUnloadPrerequisites().
+ *
+ * @returns status code.
+ * @retval  0 on success.
+ * @retval  KLDR_ERR_NOT_LOADED_DYNAMICALLY if the module wasn't loaded dynamically.
+ * @param   pMod        The module to unload.
+ */
+int kldrDyldModDynamicUnload(PKLDRDYLDMOD pMod)
+{
+    if (pMod->cDynRefs == 0)
+        return KLDR_ERR_NOT_LOADED_DYNAMICALLY;
+    KLDRDYLDMOD_ASSERT(pMod->cDynRefs <= pMod->cRefs);
+    KLDRDYLDMOD_ASSERT(pMod->enmState == KLDRSTATE_GOOD);
+
+    pMod->cRefs--;
+    pMod->cDynRefs--;
+    if (pMod->cRefs > 0)
+        return 0;
+
+    /*
+     * The module should be unloaded.
+     */
+    kldrDyldModUnloadPrerequisites(pMod);
+    return 0;
+}
+
+
+/**
+ * Worker for kldrDyldModUnloadPrerequisites.
+ *
+ * @returns The number of modules that now can be unloaded.
+ * @param   pMod    The module in  question.
+ */
+static uint32_t kldrDyldModUnloadPrerequisitesOne(PKLDRDYLDMOD pMod)
+{
+    PKLDRDYLDMOD    pMod2;
+    uint32_t        cToUnload = 0;
+    uint32_t        i;
+
+    KLDRDYLDMOD_ASSERT(pMod->papPrereqs);
+
+    /*
+     * Release the one in this module.
+     */
+    for (i = 0; i < pMod->cPrereqs; i++)
+    {
+        pMod2 = pMod->papPrereqs[i];
+        if (pMod2)
+        {
+            /* do the derefering ourselves or we'll end up in a recursive loop here. */
+            KLDRDYLDMOD_ASSERT(pMod2->cDepRefs > 0);
+            KLDRDYLDMOD_ASSERT(pMod2->cRefs >= pMod2->cDepRefs);
+            pMod2->cDepRefs--;
+            pMod2->cRefs--;
+            cToUnload += !pMod2->cRefs;
+        }
+    }
+
+    /*
+     * Change the state
+     */
+    switch (pMod->enmState)
+    {
+        case KLDRSTATE_LOADED_PREREQUISITES:
+        case KLDRSTATE_FIXED_UP:
+            pMod->enmState = KLDRSTATE_PENDING_DESTROY;
+            kldrDyldModUnlink(pMod);
+            break;
+
+        case KLDRSTATE_PENDING_INITIALIZATION:
+            pMod->enmState = KLDRSTATE_PENDING_GC;
+            break;
+
+        case KLDRSTATE_RELOADED_FIXED_UP:
+        case KLDRSTATE_RELOADED_LOADED_PREREQUISITES:
+        case KLDRSTATE_GOOD:
+            pMod->enmState = KLDRSTATE_PENDING_TERMINATION;
+            break;
+
+        case KLDRSTATE_INITIALIZATION_FAILED:
+            break;
+
+        default:
+            KLDRDYLDMOD_ASSERT(!"invalid state");
+            break;
+    }
+
+    return cToUnload;
+}
+
+
+/**
+ * This is the heart of the unload code.
+ *
+ * It will recursivly (using the load list) initiate module unloading
+ * of all affected modules.
+ *
+ * This function will cause a state transition ot PENDING_DESTROY, PENDING_GC
+ * or PENDING_TERMINATION depending on the module state. There is one exception
+ * to this, and that's INITIALIZATION_FAILED, where the state will not be changed.
+ *
+ * @param   pMod        The module which prerequisites should be unloaded.
+ */
 void kldrDyldModUnloadPrerequisites(PKLDRDYLDMOD pMod)
 {
-
-}
+    uint32_t        cToUnload;
+
+    /* sanity */
+#ifdef KLDRDYLD_STRICT
+    {
+    PKLDRDYLDMOD pMod2;
+    for (pMod2 = kLdrDyldHead; pMod2; pMod2 = pMod2->Load.pNext)
+        KLDRDYLDMOD_ASSERT(pMod2->enmState != KLDRSTATE_GOOD || pMod2->cRefs);
+    }
+#endif
+    KLDRDYLDMOD_ASSERT(pMod->papPrereqs);
+
+    /*
+     * Unload prereqs of the module we're called on first.
+     */
+    cToUnload = kldrDyldModUnloadPrerequisitesOne(pMod);
+
+    /*
+     * Iterate the load list in a cyclic manner until there are no more
+     * modules that can be pushed on into unloading.
+     */
+    while (cToUnload)
+    {
+        cToUnload = 0;
+        for (pMod = kLdrDyldHead; pMod; pMod = pMod->Load.pNext)
+        {
+            if (    pMod->cRefs
+                ||  pMod->enmState >= KLDRSTATE_PENDING_TERMINATION
+                ||  pMod->enmState < KLDRSTATE_LOADED_PREREQUISITES)
+                continue;
+            cToUnload += kldrDyldModUnloadPrerequisitesOne(pMod);
+        }
+    }
+}
+
+
+