You must choose exactly one of these two flags in every dlopen() call:

When you dlopen() a library that itself depends on other libraries, those dependencies are automatically loaded too. This is called the dependency tree.

All libraries in the dependency tree get their reference counts incremented. When you dlclose(“plugin.so”) and its count drops to 0, its dependencies are also dlclosed (recursively).

/* flags_demo.c — demonstrates RTLD_LAZY vs RTLD_NOW */
#include <stdio.h>
#include <dlfcn.h>
#include <stdlib.h>

void try_load(const char *lib, int flags, const char *flag_name) {
    printf("\nAttempting dlopen(\"%s\", %s)...\n", lib, flag_name);
    void *handle = dlopen(lib, flags);
    if (handle) {
        printf("  SUCCESS — library loaded\n");
        dlclose(handle);
    } else {
        printf("  FAILED — %s\n", dlerror());
    }
}

int main(void) {
    /* Try loading an existing library with RTLD_LAZY */
    try_load("libm.so.6", RTLD_LAZY,  "RTLD_LAZY");

    /* Try loading an existing library with RTLD_NOW */
    try_load("libm.so.6", RTLD_NOW,   "RTLD_NOW");

    /* Try loading a non-existent library */
    try_load("libdoesnotexist.so", RTLD_LAZY, "RTLD_LAZY");

    return 0;
}

gcc flags_demo.c -ldl -o flags_demo
./flags_demo

# Output:
# Attempting dlopen("libm.so.6", RTLD_LAZY)...
#   SUCCESS — library loaded
#
# Attempting dlopen("libm.so.6", RTLD_NOW)...
#   SUCCESS — library loaded
#
# Attempting dlopen("libdoesnotexist.so", RTLD_LAZY)...
#   FAILED — libdoesnotexist.so: cannot open shared object file: No such file or directory

/* Demonstrates how RTLD_GLOBAL makes symbols available to later-loaded libraries */

/* shared_util.c — utility library loaded first */
#include <stdio.h>
void util_function(void) {
    printf("util_function() called from shared_util.so\n");
}

/* consumer.c — library that calls util_function() without linking it */
/* This only works if shared_util.so was loaded with RTLD_GLOBAL */
extern void util_function(void);
void consumer_run(void) {
    printf("consumer_run(): calling util_function...\n");
    util_function();
}

/* main_global.c — loads shared_util.so with RTLD_GLOBAL,
   then loads consumer.so (which uses util_function) */
#include <stdio.h>
#include <dlfcn.h>
#include <stdlib.h>

int main(void) {
    /* Load utility library globally so its symbols are available */
    void *util = dlopen("./shared_util.so", RTLD_LAZY | RTLD_GLOBAL);
    if (!util) { fprintf(stderr, "%s\n", dlerror()); exit(1); }

    /* Now load consumer — it can find util_function because of RTLD_GLOBAL */
    void *cons = dlopen("./consumer.so", RTLD_LAZY);
    if (!cons) {
        fprintf(stderr, "consumer load failed: %s\n", dlerror());
        /* With RTLD_LOCAL above, this would fail */
        dlclose(util);
        exit(1);
    }

    void (*run)(void);
    *(void **)(&run) = dlsym(cons, "consumer_run");
    if (run) (*run)();

    dlclose(cons);
    dlclose(util);
    return 0;
}

/* noload_check.c — use RTLD_NOLOAD to check if a library is in memory */
#include <stdio.h>
#include <dlfcn.h>
#include <stdlib.h>

int is_library_loaded(const char *libname) {
    /* RTLD_NOLOAD: do NOT load if absent; just return handle if present */
    void *h = dlopen(libname, RTLD_NOLOAD | RTLD_LAZY);
    if (h) {
        dlclose(h); /* decrement reference count we just incremented */
        return 1;
    }
    return 0;
}

int main(void) {
    /* libc is always loaded */
    printf("libc.so.6 loaded?   %s\n",
           is_library_loaded("libc.so.6") ? "YES" : "NO");

    printf("libm.so.6 loaded?   %s\n",
           is_library_loaded("libm.so.6") ? "YES" : "NO");

    /* Now explicitly load libm */
    void *libm = dlopen("libm.so.6", RTLD_LAZY);

    printf("libm.so.6 loaded now? %s\n",
           is_library_loaded("libm.so.6") ? "YES" : "NO");

    dlclose(libm);
    return 0;
}

gcc noload_check.c -ldl -o noload_check
./noload_check
# libc.so.6 loaded?   YES
# libm.so.6 loaded?   NO
# libm.so.6 loaded now? YES