dfmgr.c File Reference

#include "postgres.h"
#include <sys/stat.h>
#include <dlfcn.h>
#include "fmgr.h"
#include "lib/stringinfo.h"
#include "miscadmin.h"
#include "storage/fd.h"
#include "storage/shmem.h"
#include "utils/hsearch.h"

Include dependency graph for dfmgr.c:

Go to the source code of this file.

Data Structures
struct	rendezvousHashEntry
struct	DynamicFileList

Macros
#define	SAME_INODE(A, B)   ((A).st_ino == (B).inode && (A).st_dev == (B).device)

Typedefs
typedef void(*	PG_init_t) (void)

Functions
static void *	internal_load_library (const char *libname)
static pg_noreturn void	incompatible_module_error (const char *libname, const Pg_abi_values *module_magic_data)
static char *	expand_dynamic_library_name (const char *name)
static void	check_restricted_library_name (const char *name)
void *	load_external_function (const char *filename, const char *funcname, bool signalNotFound, void **filehandle)
void	load_file (const char *filename, bool restricted)
void *	lookup_external_function (void *filehandle, const char *funcname)
DynamicFileList *	get_first_loaded_module (void)
DynamicFileList *	get_next_loaded_module (DynamicFileList *dfptr)
void	get_loaded_module_details (DynamicFileList *dfptr, const char **library_path, const char **module_name, const char **module_version)
char *	substitute_path_macro (const char *str, const char *macro, const char *value)
char *	find_in_path (const char *basename, const char *path, const char *path_param, const char *macro, const char *macro_val)
void **	find_rendezvous_variable (const char *varName)
Size	EstimateLibraryStateSpace (void)
void	SerializeLibraryState (Size maxsize, char *start_address)
void	RestoreLibraryState (char *start_address)

Variables
static DynamicFileList *	file_list = NULL
static DynamicFileList *	file_tail = NULL
char *	Dynamic_library_path
static const Pg_abi_values	magic_data = PG_MODULE_ABI_DATA

Macro Definition Documentation

SAME_INODE

#define SAME_INODE	(		A,
			B
	)		((A).st_ino == (B).inode && (A).st_dev == (B).device)

Definition at line 64 of file dfmgr.c.

Typedef Documentation

PG_init_t

typedef void(* PG_init_t) (void)

Definition at line 32 of file dfmgr.c.

Function Documentation

check_restricted_library_name()

static void check_restricted_library_name ( const char *  name )

static

Definition at line 521 of file dfmgr.c.

{
    if (strncmp(name, "$libdir/plugins/", 16) != 0 ||
        first_dir_separator(name + 16) != NULL)
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("access to library \"%s\" is not allowed",
                        name)));
}

References ereport, errcode(), errmsg(), ERROR, first_dir_separator(), and name.

Referenced by load_file().

EstimateLibraryStateSpace()

Size EstimateLibraryStateSpace

(

void

)

Definition at line 702 of file dfmgr.c.

{
    DynamicFileList *file_scanner;
    Size        size = 1;
 
    for (file_scanner = file_list;
         file_scanner != NULL;
         file_scanner = file_scanner->next)
        size = add_size(size, strlen(file_scanner->filename) + 1);
 
    return size;
}

References add_size(), file_list, DynamicFileList::filename, and DynamicFileList::next.

Referenced by InitializeParallelDSM().

expand_dynamic_library_name()

static char * expand_dynamic_library_name ( const char *  name )

static

Definition at line 466 of file dfmgr.c.

{
    bool        have_slash;
    char       *new;
    char       *full;
 
    Assert(name);
 
    have_slash = (first_dir_separator(name) != NULL);
 
    if (!have_slash)
    {
        full = find_in_path(name, Dynamic_library_path, "dynamic_library_path", "$libdir", pkglib_path);
        if (full)
            return full;
    }
    else
    {
        full = substitute_path_macro(name, "$libdir", pkglib_path);
        if (pg_file_exists(full))
            return full;
        pfree(full);
    }
 
    new = psprintf("%s%s", name, DLSUFFIX);
 
    if (!have_slash)
    {
        full = find_in_path(new, Dynamic_library_path, "dynamic_library_path", "$libdir", pkglib_path);
        pfree(new);
        if (full)
            return full;
    }
    else
    {
        full = substitute_path_macro(new, "$libdir", pkglib_path);
        pfree(new);
        if (pg_file_exists(full))
            return full;
        pfree(full);
    }
 
    /*
     * If we can't find the file, just return the string as-is. The ensuing
     * load attempt will fail and report a suitable message.
     */
    return pstrdup(name);
}

References Assert(), Dynamic_library_path, find_in_path(), first_dir_separator(), name, pfree(), pg_file_exists(), pkglib_path, psprintf(), pstrdup(), and substitute_path_macro().

Referenced by load_external_function(), and load_file().

find_in_path()

char * find_in_path	(	const char *	basename,
		const char *	path,
		const char *	path_param,
		const char *	macro,
		const char *	macro_val
	)

Definition at line 574 of file dfmgr.c.

{
    const char *p;
    size_t      baselen;
 
    Assert(basename != NULL);
    Assert(first_dir_separator(basename) == NULL);
    Assert(path != NULL);
    Assert(path_param != NULL);
 
    p = path;
 
    /*
     * If the path variable is empty, don't do a path search.
     */
    if (strlen(p) == 0)
        return NULL;
 
    baselen = strlen(basename);
 
    for (;;)
    {
        size_t      len;
        char       *piece;
        char       *mangled;
        char       *full;
 
        piece = first_path_var_separator(p);
        if (piece == p)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_NAME),
                     errmsg("zero-length component in parameter \"%s\"", path_param)));
 
        if (piece == NULL)
            len = strlen(p);
        else
            len = piece - p;
 
        piece = palloc(len + 1);
        strlcpy(piece, p, len + 1);
 
        mangled = substitute_path_macro(piece, macro, macro_val);
        pfree(piece);
 
        canonicalize_path(mangled);
 
        /* only absolute paths */
        if (!is_absolute_path(mangled))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_NAME),
                     errmsg("component in parameter \"%s\" is not an absolute path", path_param)));
 
        full = palloc(strlen(mangled) + 1 + baselen + 1);
        sprintf(full, "%s/%s", mangled, basename);
        pfree(mangled);
 
        elog(DEBUG3, "%s: trying \"%s\"", __func__, full);
 
        if (pg_file_exists(full))
            return full;
 
        pfree(full);
 
        if (p[len] == '\0')
            break;
        else
            p += len + 1;
    }
 
    return NULL;
}

References Assert(), canonicalize_path(), DEBUG3, elog, ereport, errcode(), errmsg(), ERROR, first_dir_separator(), first_path_var_separator(), is_absolute_path, len, palloc(), pfree(), pg_file_exists(), sprintf, strlcpy(), and substitute_path_macro().

Referenced by expand_dynamic_library_name().

find_rendezvous_variable()

void ** find_rendezvous_variable

(

const char *

varName

)

Definition at line 664 of file dfmgr.c.

{
    static HTAB *rendezvousHash = NULL;
 
    rendezvousHashEntry *hentry;
    bool        found;
 
    /* Create a hashtable if we haven't already done so in this process */
    if (rendezvousHash == NULL)
    {
        HASHCTL     ctl;
 
        ctl.keysize = NAMEDATALEN;
        ctl.entrysize = sizeof(rendezvousHashEntry);
        rendezvousHash = hash_create("Rendezvous variable hash",
                                     16,
                                     &ctl,
                                     HASH_ELEM | HASH_STRINGS);
    }
 
    /* Find or create the hashtable entry for this varName */
    hentry = (rendezvousHashEntry *) hash_search(rendezvousHash,
                                                 varName,
                                                 HASH_ENTER,
                                                 &found);
 
    /* Initialize to NULL if first time */
    if (!found)
        hentry->varValue = NULL;
 
    return &hentry->varValue;
}

References ctl, hash_create(), HASH_ELEM, HASH_ENTER, hash_search(), HASH_STRINGS, NAMEDATALEN, and rendezvousHashEntry::varValue.

Referenced by _PG_init().

get_first_loaded_module()

DynamicFileList * get_first_loaded_module

(

void

)

Definition at line 425 of file dfmgr.c.

{
    return file_list;
}

References file_list.

Referenced by pg_get_loaded_modules().

get_loaded_module_details()

void get_loaded_module_details	(	DynamicFileList *	dfptr,
		const char **	library_path,
		const char **	module_name,
		const char **	module_version
	)

Definition at line 445 of file dfmgr.c.

{
    *library_path = dfptr->filename;
    *module_name = dfptr->magic->name;
    *module_version = dfptr->magic->version;
}

References DynamicFileList::filename, DynamicFileList::magic, Pg_magic_struct::name, and Pg_magic_struct::version.

Referenced by pg_get_loaded_modules().

get_next_loaded_module()

DynamicFileList * get_next_loaded_module

(

DynamicFileList *

dfptr

)

Definition at line 431 of file dfmgr.c.

{
    return dfptr->next;
}

References DynamicFileList::next.

Referenced by pg_get_loaded_modules().

incompatible_module_error()

static void incompatible_module_error ( const char *  libname, const Pg_abi_values *  module_magic_data  )

static

Definition at line 316 of file dfmgr.c.

{
    StringInfoData details;
 
    /*
     * If the version doesn't match, just report that, because the rest of the
     * block might not even have the fields we expect.
     */
    if (magic_data.version != module_magic_data->version)
    {
        char        library_version[32];
 
        if (module_magic_data->version >= 1000)
            snprintf(library_version, sizeof(library_version), "%d",
                     module_magic_data->version / 100);
        else
            snprintf(library_version, sizeof(library_version), "%d.%d",
                     module_magic_data->version / 100,
                     module_magic_data->version % 100);
        ereport(ERROR,
                (errmsg("incompatible library \"%s\": version mismatch",
                        libname),
                 errdetail("Server is version %d, library is version %s.",
                           magic_data.version / 100, library_version)));
    }
 
    /*
     * Similarly, if the ABI extra field doesn't match, error out.  Other
     * fields below might also mismatch, but that isn't useful information if
     * you're using the wrong product altogether.
     */
    if (strcmp(module_magic_data->abi_extra, magic_data.abi_extra) != 0)
    {
        ereport(ERROR,
                (errmsg("incompatible library \"%s\": ABI mismatch",
                        libname),
                 errdetail("Server has ABI \"%s\", library has \"%s\".",
                           magic_data.abi_extra,
                           module_magic_data->abi_extra)));
    }
 
    /*
     * Otherwise, spell out which fields don't agree.
     *
     * XXX this code has to be adjusted any time the set of fields in a magic
     * block change!
     */
    initStringInfo(&details);
 
    if (module_magic_data->funcmaxargs != magic_data.funcmaxargs)
    {
        if (details.len)
            appendStringInfoChar(&details, '\n');
        appendStringInfo(&details,
        /* translator: %s is a variable name and %d its values */
                         _("Server has %s = %d, library has %d."),
                         "FUNC_MAX_ARGS", magic_data.funcmaxargs,
                         module_magic_data->funcmaxargs);
    }
    if (module_magic_data->indexmaxkeys != magic_data.indexmaxkeys)
    {
        if (details.len)
            appendStringInfoChar(&details, '\n');
        appendStringInfo(&details,
        /* translator: %s is a variable name and %d its values */
                         _("Server has %s = %d, library has %d."),
                         "INDEX_MAX_KEYS", magic_data.indexmaxkeys,
                         module_magic_data->indexmaxkeys);
    }
    if (module_magic_data->namedatalen != magic_data.namedatalen)
    {
        if (details.len)
            appendStringInfoChar(&details, '\n');
        appendStringInfo(&details,
        /* translator: %s is a variable name and %d its values */
                         _("Server has %s = %d, library has %d."),
                         "NAMEDATALEN", magic_data.namedatalen,
                         module_magic_data->namedatalen);
    }
    if (module_magic_data->float8byval != magic_data.float8byval)
    {
        if (details.len)
            appendStringInfoChar(&details, '\n');
        appendStringInfo(&details,
        /* translator: %s is a variable name and %d its values */
                         _("Server has %s = %s, library has %s."),
                         "FLOAT8PASSBYVAL", magic_data.float8byval ? "true" : "false",
                         module_magic_data->float8byval ? "true" : "false");
    }
 
    if (details.len == 0)
        appendStringInfoString(&details,
                               _("Magic block has unexpected length or padding difference."));
 
    ereport(ERROR,
            (errmsg("incompatible library \"%s\": magic block mismatch",
                    libname),
             errdetail_internal("%s", details.data)));
}

References _, Pg_abi_values::abi_extra, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), StringInfoData::data, ereport, errdetail(), errdetail_internal(), errmsg(), ERROR, Pg_abi_values::float8byval, Pg_abi_values::funcmaxargs, Pg_abi_values::indexmaxkeys, initStringInfo(), StringInfoData::len, magic_data, Pg_abi_values::namedatalen, snprintf, and Pg_abi_values::version.

Referenced by internal_load_library().

internal_load_library()

static void * internal_load_library ( const char *  libname )

static

Definition at line 189 of file dfmgr.c.

{
    DynamicFileList *file_scanner;
    PGModuleMagicFunction magic_func;
    char       *load_error;
    struct stat stat_buf;
    PG_init_t   PG_init;
 
    /*
     * Scan the list of loaded FILES to see if the file has been loaded.
     */
    for (file_scanner = file_list;
         file_scanner != NULL &&
         strcmp(libname, file_scanner->filename) != 0;
         file_scanner = file_scanner->next)
        ;
 
    if (file_scanner == NULL)
    {
        /*
         * Check for same files - different paths (ie, symlink or link)
         */
        if (stat(libname, &stat_buf) == -1)
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not access file \"%s\": %m",
                            libname)));
 
        for (file_scanner = file_list;
             file_scanner != NULL &&
             !SAME_INODE(stat_buf, *file_scanner);
             file_scanner = file_scanner->next)
            ;
    }
 
    if (file_scanner == NULL)
    {
        /*
         * File not loaded yet.
         */
        file_scanner = (DynamicFileList *)
            malloc(offsetof(DynamicFileList, filename) + strlen(libname) + 1);
        if (file_scanner == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_OUT_OF_MEMORY),
                     errmsg("out of memory")));
 
        MemSet(file_scanner, 0, offsetof(DynamicFileList, filename));
        strcpy(file_scanner->filename, libname);
        file_scanner->device = stat_buf.st_dev;
#ifndef WIN32
        file_scanner->inode = stat_buf.st_ino;
#endif
        file_scanner->next = NULL;
 
        file_scanner->handle = dlopen(file_scanner->filename, RTLD_NOW | RTLD_GLOBAL);
        if (file_scanner->handle == NULL)
        {
            load_error = dlerror();
            free(file_scanner);
            /* errcode_for_file_access might not be appropriate here? */
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not load library \"%s\": %s",
                            libname, load_error)));
        }
 
        /* Check the magic function to determine compatibility */
        magic_func = (PGModuleMagicFunction)
            dlsym(file_scanner->handle, PG_MAGIC_FUNCTION_NAME_STRING);
        if (magic_func)
        {
            const Pg_magic_struct *magic_data_ptr = (*magic_func) ();
 
            /* Check ABI compatibility fields */
            if (magic_data_ptr->len != sizeof(Pg_magic_struct) ||
                memcmp(&magic_data_ptr->abi_fields, &magic_data,
                       sizeof(Pg_abi_values)) != 0)
            {
                /* copy data block before unlinking library */
                Pg_magic_struct module_magic_data = *magic_data_ptr;
 
                /* try to close library */
                dlclose(file_scanner->handle);
                free(file_scanner);
 
                /* issue suitable complaint */
                incompatible_module_error(libname, &module_magic_data.abi_fields);
            }
 
            /* Remember the magic block's location for future use */
            file_scanner->magic = magic_data_ptr;
        }
        else
        {
            /* try to close library */
            dlclose(file_scanner->handle);
            free(file_scanner);
            /* complain */
            ereport(ERROR,
                    (errmsg("incompatible library \"%s\": missing magic block",
                            libname),
                     errhint("Extension libraries are required to use the PG_MODULE_MAGIC macro.")));
        }
 
        /*
         * If the library has a _PG_init() function, call it.
         */
        PG_init = (PG_init_t) dlsym(file_scanner->handle, "_PG_init");
        if (PG_init)
            (*PG_init) ();
 
        /* OK to link it into list */
        if (file_list == NULL)
            file_list = file_scanner;
        else
            file_tail->next = file_scanner;
        file_tail = file_scanner;
    }
 
    return file_scanner->handle;
}

References Pg_magic_struct::abi_fields, DynamicFileList::device, dlclose(), dlerror(), dlopen(), dlsym(), ereport, errcode(), errcode_for_file_access(), errhint(), errmsg(), ERROR, file_list, file_tail, DynamicFileList::filename, filename, free, DynamicFileList::handle, incompatible_module_error(), DynamicFileList::inode, Pg_magic_struct::len, DynamicFileList::magic, magic_data, malloc, MemSet, DynamicFileList::next, PG_MAGIC_FUNCTION_NAME_STRING, RTLD_GLOBAL, RTLD_NOW, SAME_INODE, stat::st_dev, stat::st_ino, and stat.

Referenced by load_external_function(), load_file(), and RestoreLibraryState().

load_external_function()

void * load_external_function	(	const char *	filename,
		const char *	funcname,
		bool	signalNotFound,
		void **	filehandle
	)

Definition at line 95 of file dfmgr.c.

{
    char       *fullname;
    void       *lib_handle;
    void       *retval;
 
    /*
     * For extensions with hardcoded '$libdir/' library names, we strip the
     * prefix to allow the library search path to be used. This is done only
     * for simple names (e.g., "$libdir/foo"), not for nested paths (e.g.,
     * "$libdir/foo/bar").
     *
     * For nested paths, 'expand_dynamic_library_name' directly expands the
     * '$libdir' macro, so we leave them untouched.
     */
    if (strncmp(filename, "$libdir/", 8) == 0)
    {
        if (first_dir_separator(filename + 8) == NULL)
            filename += 8;
    }
 
    /* Expand the possibly-abbreviated filename to an exact path name */
    fullname = expand_dynamic_library_name(filename);
 
    /* Load the shared library, unless we already did */
    lib_handle = internal_load_library(fullname);
 
    /* Return handle if caller wants it */
    if (filehandle)
        *filehandle = lib_handle;
 
    /* Look up the function within the library. */
    retval = dlsym(lib_handle, funcname);
 
    if (retval == NULL && signalNotFound)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_FUNCTION),
                 errmsg("could not find function \"%s\" in file \"%s\"",
                        funcname, fullname)));
 
    pfree(fullname);
    return retval;
}

References dlsym(), ereport, errcode(), errmsg(), ERROR, expand_dynamic_library_name(), filename, first_dir_separator(), funcname, internal_load_library(), and pfree().

Referenced by _PG_init(), fmgr_c_validator(), fmgr_info_C_lang(), llvm_resolve_symbol(), load_validator_library(), LoadArchiveLibrary(), LoadOutputPlugin(), LookupBackgroundWorkerFunction(), LookupParallelWorkerFunction(), and provider_init().

load_file()

void load_file	(	const char *	filename,
		bool	restricted
	)

Definition at line 149 of file dfmgr.c.

{
    char       *fullname;
 
    /* Apply security restriction if requested */
    if (restricted)
        check_restricted_library_name(filename);
 
    /* Expand the possibly-abbreviated filename to an exact path name */
    fullname = expand_dynamic_library_name(filename);
 
    /* Load the shared library, unless we already did */
    (void) internal_load_library(fullname);
 
    pfree(fullname);
}

References check_restricted_library_name(), expand_dynamic_library_name(), filename, internal_load_library(), pfree(), and restricted.

Referenced by AlterSubscription(), AlterSubscription_refresh(), CreateSubscription(), DropSubscription(), load_libraries(), pg_sync_replication_slots(), ReplicationSlotDropAtPubNode(), ReplSlotSyncWorkerMain(), SetupApplyOrSyncWorker(), standard_ProcessUtility(), and WalReceiverMain().

lookup_external_function()

void * lookup_external_function	(	void *	filehandle,
		const char *	funcname
	)

Definition at line 171 of file dfmgr.c.

{
    return dlsym(filehandle, funcname);
}

References dlsym(), and funcname.

Referenced by fetch_finfo_record().

RestoreLibraryState()

void RestoreLibraryState

(

char *

start_address

)

Definition at line 741 of file dfmgr.c.

{
    while (*start_address != '\0')
    {
        internal_load_library(start_address);
        start_address += strlen(start_address) + 1;
    }
}

References internal_load_library().

Referenced by ParallelWorkerMain().

SerializeLibraryState()

void SerializeLibraryState	(	Size	maxsize,
		char *	start_address
	)

Definition at line 719 of file dfmgr.c.

{
    DynamicFileList *file_scanner;
 
    for (file_scanner = file_list;
         file_scanner != NULL;
         file_scanner = file_scanner->next)
    {
        Size        len;
 
        len = strlcpy(start_address, file_scanner->filename, maxsize) + 1;
        Assert(len < maxsize);
        maxsize -= len;
        start_address += len;
    }
    start_address[0] = '\0';
}

References Assert(), file_list, DynamicFileList::filename, len, DynamicFileList::next, and strlcpy().

Referenced by InitializeParallelDSM().

substitute_path_macro()

char * substitute_path_macro	(	const char *	str,
		const char *	macro,
		const char *	value
	)

Definition at line 536 of file dfmgr.c.

{
    const char *sep_ptr;
 
    Assert(str != NULL);
    Assert(macro[0] == '$');
 
    /* Currently, we only recognize $macro at the start of the string */
    if (str[0] != '$')
        return pstrdup(str);
 
    if ((sep_ptr = first_dir_separator(str)) == NULL)
        sep_ptr = str + strlen(str);
 
    if (strlen(macro) != sep_ptr - str ||
        strncmp(str, macro, strlen(macro)) != 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_NAME),
                 errmsg("invalid macro name in path: %s",
                        str)));
 
    return psprintf("%s%s", value, sep_ptr);
}

References Assert(), ereport, errcode(), errmsg(), ERROR, first_dir_separator(), psprintf(), pstrdup(), str, and value.

Referenced by expand_dynamic_library_name(), find_in_path(), and get_extension_control_directories().

Variable Documentation

Dynamic_library_path

char* Dynamic_library_path

Definition at line 69 of file dfmgr.c.

Referenced by expand_dynamic_library_name().

file_list

DynamicFileList* file_list = NULL

static

Definition at line 59 of file dfmgr.c.

Referenced by EstimateLibraryStateSpace(), get_first_loaded_module(), internal_load_library(), and SerializeLibraryState().

file_tail

DynamicFileList* file_tail = NULL

static

Definition at line 60 of file dfmgr.c.

Referenced by internal_load_library().

magic_data

const Pg_abi_values magic_data = PG_MODULE_ABI_DATA

static

Definition at line 78 of file dfmgr.c.

Referenced by incompatible_module_error(), and internal_load_library().