LCOV - code coverage report
Current view: top level - src/backend/utils/fmgr - dfmgr.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 134 198 67.7 %
Date: 2024-04-25 00:11:39 Functions: 11 13 84.6 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * dfmgr.c
       4             :  *    Dynamic function manager code.
       5             :  *
       6             :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/utils/fmgr/dfmgr.c
      12             :  *
      13             :  *-------------------------------------------------------------------------
      14             :  */
      15             : #include "postgres.h"
      16             : 
      17             : #include <sys/stat.h>
      18             : 
      19             : #ifndef WIN32
      20             : #include <dlfcn.h>
      21             : 
      22             : /*
      23             :  * On macOS, <dlfcn.h> insists on including <stdbool.h>.  If we're not
      24             :  * using stdbool, undef bool to undo the damage.
      25             :  */
      26             : #ifndef PG_USE_STDBOOL
      27             : #ifdef bool
      28             : #undef bool
      29             : #endif
      30             : #endif
      31             : #endif                          /* !WIN32 */
      32             : 
      33             : #include "fmgr.h"
      34             : #include "lib/stringinfo.h"
      35             : #include "miscadmin.h"
      36             : #include "storage/fd.h"
      37             : #include "storage/shmem.h"
      38             : #include "utils/hsearch.h"
      39             : 
      40             : 
      41             : /* signature for PostgreSQL-specific library init function */
      42             : typedef void (*PG_init_t) (void);
      43             : 
      44             : /* hashtable entry for rendezvous variables */
      45             : typedef struct
      46             : {
      47             :     char        varName[NAMEDATALEN];   /* hash key (must be first) */
      48             :     void       *varValue;
      49             : } rendezvousHashEntry;
      50             : 
      51             : /*
      52             :  * List of dynamically loaded files (kept in malloc'd memory).
      53             :  */
      54             : 
      55             : typedef struct df_files
      56             : {
      57             :     struct df_files *next;      /* List link */
      58             :     dev_t       device;         /* Device file is on */
      59             : #ifndef WIN32                   /* ensures we never again depend on this under
      60             :                                  * win32 */
      61             :     ino_t       inode;          /* Inode number of file */
      62             : #endif
      63             :     void       *handle;         /* a handle for pg_dl* functions */
      64             :     char        filename[FLEXIBLE_ARRAY_MEMBER];    /* Full pathname of file */
      65             : } DynamicFileList;
      66             : 
      67             : static DynamicFileList *file_list = NULL;
      68             : static DynamicFileList *file_tail = NULL;
      69             : 
      70             : /* stat() call under Win32 returns an st_ino field, but it has no meaning */
      71             : #ifndef WIN32
      72             : #define SAME_INODE(A,B) ((A).st_ino == (B).inode && (A).st_dev == (B).device)
      73             : #else
      74             : #define SAME_INODE(A,B) false
      75             : #endif
      76             : 
      77             : char       *Dynamic_library_path;
      78             : 
      79             : static void *internal_load_library(const char *libname);
      80             : static void incompatible_module_error(const char *libname,
      81             :                                       const Pg_magic_struct *module_magic_data) pg_attribute_noreturn();
      82             : static char *expand_dynamic_library_name(const char *name);
      83             : static void check_restricted_library_name(const char *name);
      84             : static char *substitute_libpath_macro(const char *name);
      85             : static char *find_in_dynamic_libpath(const char *basename);
      86             : 
      87             : /* Magic structure that module needs to match to be accepted */
      88             : static const Pg_magic_struct magic_data = PG_MODULE_MAGIC_DATA;
      89             : 
      90             : 
      91             : /*
      92             :  * Load the specified dynamic-link library file, and look for a function
      93             :  * named funcname in it.
      94             :  *
      95             :  * If the function is not found, we raise an error if signalNotFound is true,
      96             :  * else return NULL.  Note that errors in loading the library
      97             :  * will provoke ereport() regardless of signalNotFound.
      98             :  *
      99             :  * If filehandle is not NULL, then *filehandle will be set to a handle
     100             :  * identifying the library file.  The filehandle can be used with
     101             :  * lookup_external_function to lookup additional functions in the same file
     102             :  * at less cost than repeating load_external_function.
     103             :  */
     104             : void *
     105       13424 : load_external_function(const char *filename, const char *funcname,
     106             :                        bool signalNotFound, void **filehandle)
     107             : {
     108             :     char       *fullname;
     109             :     void       *lib_handle;
     110             :     void       *retval;
     111             : 
     112             :     /* Expand the possibly-abbreviated filename to an exact path name */
     113       13424 :     fullname = expand_dynamic_library_name(filename);
     114             : 
     115             :     /* Load the shared library, unless we already did */
     116       13424 :     lib_handle = internal_load_library(fullname);
     117             : 
     118             :     /* Return handle if caller wants it */
     119       13416 :     if (filehandle)
     120       10692 :         *filehandle = lib_handle;
     121             : 
     122             :     /* Look up the function within the library. */
     123       13416 :     retval = dlsym(lib_handle, funcname);
     124             : 
     125       13416 :     if (retval == NULL && signalNotFound)
     126           6 :         ereport(ERROR,
     127             :                 (errcode(ERRCODE_UNDEFINED_FUNCTION),
     128             :                  errmsg("could not find function \"%s\" in file \"%s\"",
     129             :                         funcname, fullname)));
     130             : 
     131       13410 :     pfree(fullname);
     132       13410 :     return retval;
     133             : }
     134             : 
     135             : /*
     136             :  * This function loads a shlib file without looking up any particular
     137             :  * function in it.  If the same shlib has previously been loaded,
     138             :  * unload and reload it.
     139             :  *
     140             :  * When 'restricted' is true, only libraries in the presumed-secure
     141             :  * directory $libdir/plugins may be referenced.
     142             :  */
     143             : void
     144        2172 : load_file(const char *filename, bool restricted)
     145             : {
     146             :     char       *fullname;
     147             : 
     148             :     /* Apply security restriction if requested */
     149        2172 :     if (restricted)
     150           0 :         check_restricted_library_name(filename);
     151             : 
     152             :     /* Expand the possibly-abbreviated filename to an exact path name */
     153        2172 :     fullname = expand_dynamic_library_name(filename);
     154             : 
     155             :     /* Load the shared library */
     156        2172 :     (void) internal_load_library(fullname);
     157             : 
     158        2172 :     pfree(fullname);
     159        2172 : }
     160             : 
     161             : /*
     162             :  * Lookup a function whose library file is already loaded.
     163             :  * Return NULL if not found.
     164             :  */
     165             : void *
     166       10686 : lookup_external_function(void *filehandle, const char *funcname)
     167             : {
     168       10686 :     return dlsym(filehandle, funcname);
     169             : }
     170             : 
     171             : 
     172             : /*
     173             :  * Load the specified dynamic-link library file, unless it already is
     174             :  * loaded.  Return the pg_dl* handle for the file.
     175             :  *
     176             :  * Note: libname is expected to be an exact name for the library file.
     177             :  *
     178             :  * NB: There is presently no way to unload a dynamically loaded file.  We might
     179             :  * add one someday if we can convince ourselves we have safe protocols for un-
     180             :  * hooking from hook function pointers, releasing custom GUC variables, and
     181             :  * perhaps other things that are definitely unsafe currently.
     182             :  */
     183             : static void *
     184       20394 : internal_load_library(const char *libname)
     185             : {
     186             :     DynamicFileList *file_scanner;
     187             :     PGModuleMagicFunction magic_func;
     188             :     char       *load_error;
     189             :     struct stat stat_buf;
     190             :     PG_init_t   PG_init;
     191             : 
     192             :     /*
     193             :      * Scan the list of loaded FILES to see if the file has been loaded.
     194             :      */
     195       31970 :     for (file_scanner = file_list;
     196       21796 :          file_scanner != NULL &&
     197       21796 :          strcmp(libname, file_scanner->filename) != 0;
     198       11576 :          file_scanner = file_scanner->next)
     199             :         ;
     200             : 
     201       20394 :     if (file_scanner == NULL)
     202             :     {
     203             :         /*
     204             :          * Check for same files - different paths (ie, symlink or link)
     205             :          */
     206       10174 :         if (stat(libname, &stat_buf) == -1)
     207           8 :             ereport(ERROR,
     208             :                     (errcode_for_file_access(),
     209             :                      errmsg("could not access file \"%s\": %m",
     210             :                             libname)));
     211             : 
     212       16594 :         for (file_scanner = file_list;
     213        6428 :              file_scanner != NULL &&
     214        6428 :              !SAME_INODE(stat_buf, *file_scanner);
     215        6428 :              file_scanner = file_scanner->next)
     216             :             ;
     217             :     }
     218             : 
     219       20386 :     if (file_scanner == NULL)
     220             :     {
     221             :         /*
     222             :          * File not loaded yet.
     223             :          */
     224             :         file_scanner = (DynamicFileList *)
     225       10166 :             malloc(offsetof(DynamicFileList, filename) + strlen(libname) + 1);
     226       10166 :         if (file_scanner == NULL)
     227           0 :             ereport(ERROR,
     228             :                     (errcode(ERRCODE_OUT_OF_MEMORY),
     229             :                      errmsg("out of memory")));
     230             : 
     231       50830 :         MemSet(file_scanner, 0, offsetof(DynamicFileList, filename));
     232       10166 :         strcpy(file_scanner->filename, libname);
     233       10166 :         file_scanner->device = stat_buf.st_dev;
     234             : #ifndef WIN32
     235       10166 :         file_scanner->inode = stat_buf.st_ino;
     236             : #endif
     237       10166 :         file_scanner->next = NULL;
     238             : 
     239       10166 :         file_scanner->handle = dlopen(file_scanner->filename, RTLD_NOW | RTLD_GLOBAL);
     240       10166 :         if (file_scanner->handle == NULL)
     241             :         {
     242           0 :             load_error = dlerror();
     243           0 :             free(file_scanner);
     244             :             /* errcode_for_file_access might not be appropriate here? */
     245           0 :             ereport(ERROR,
     246             :                     (errcode_for_file_access(),
     247             :                      errmsg("could not load library \"%s\": %s",
     248             :                             libname, load_error)));
     249             :         }
     250             : 
     251             :         /* Check the magic function to determine compatibility */
     252       10166 :         magic_func = (PGModuleMagicFunction)
     253       10166 :             dlsym(file_scanner->handle, PG_MAGIC_FUNCTION_NAME_STRING);
     254       10166 :         if (magic_func)
     255             :         {
     256       10166 :             const Pg_magic_struct *magic_data_ptr = (*magic_func) ();
     257             : 
     258       10166 :             if (magic_data_ptr->len != magic_data.len ||
     259       10166 :                 memcmp(magic_data_ptr, &magic_data, magic_data.len) != 0)
     260             :             {
     261             :                 /* copy data block before unlinking library */
     262           0 :                 Pg_magic_struct module_magic_data = *magic_data_ptr;
     263             : 
     264             :                 /* try to close library */
     265           0 :                 dlclose(file_scanner->handle);
     266           0 :                 free(file_scanner);
     267             : 
     268             :                 /* issue suitable complaint */
     269           0 :                 incompatible_module_error(libname, &module_magic_data);
     270             :             }
     271             :         }
     272             :         else
     273             :         {
     274             :             /* try to close library */
     275           0 :             dlclose(file_scanner->handle);
     276           0 :             free(file_scanner);
     277             :             /* complain */
     278           0 :             ereport(ERROR,
     279             :                     (errmsg("incompatible library \"%s\": missing magic block",
     280             :                             libname),
     281             :                      errhint("Extension libraries are required to use the PG_MODULE_MAGIC macro.")));
     282             :         }
     283             : 
     284             :         /*
     285             :          * If the library has a _PG_init() function, call it.
     286             :          */
     287       10166 :         PG_init = (PG_init_t) dlsym(file_scanner->handle, "_PG_init");
     288       10166 :         if (PG_init)
     289        5472 :             (*PG_init) ();
     290             : 
     291             :         /* OK to link it into list */
     292       10166 :         if (file_list == NULL)
     293        6722 :             file_list = file_scanner;
     294             :         else
     295        3444 :             file_tail->next = file_scanner;
     296       10166 :         file_tail = file_scanner;
     297             :     }
     298             : 
     299       20386 :     return file_scanner->handle;
     300             : }
     301             : 
     302             : /*
     303             :  * Report a suitable error for an incompatible magic block.
     304             :  */
     305             : static void
     306           0 : incompatible_module_error(const char *libname,
     307             :                           const Pg_magic_struct *module_magic_data)
     308             : {
     309             :     StringInfoData details;
     310             : 
     311             :     /*
     312             :      * If the version doesn't match, just report that, because the rest of the
     313             :      * block might not even have the fields we expect.
     314             :      */
     315           0 :     if (magic_data.version != module_magic_data->version)
     316             :     {
     317             :         char        library_version[32];
     318             : 
     319           0 :         if (module_magic_data->version >= 1000)
     320           0 :             snprintf(library_version, sizeof(library_version), "%d",
     321           0 :                      module_magic_data->version / 100);
     322             :         else
     323           0 :             snprintf(library_version, sizeof(library_version), "%d.%d",
     324           0 :                      module_magic_data->version / 100,
     325           0 :                      module_magic_data->version % 100);
     326           0 :         ereport(ERROR,
     327             :                 (errmsg("incompatible library \"%s\": version mismatch",
     328             :                         libname),
     329             :                  errdetail("Server is version %d, library is version %s.",
     330             :                            magic_data.version / 100, library_version)));
     331             :     }
     332             : 
     333             :     /*
     334             :      * Similarly, if the ABI extra field doesn't match, error out.  Other
     335             :      * fields below might also mismatch, but that isn't useful information if
     336             :      * you're using the wrong product altogether.
     337             :      */
     338           0 :     if (strcmp(module_magic_data->abi_extra, magic_data.abi_extra) != 0)
     339             :     {
     340           0 :         ereport(ERROR,
     341             :                 (errmsg("incompatible library \"%s\": ABI mismatch",
     342             :                         libname),
     343             :                  errdetail("Server has ABI \"%s\", library has \"%s\".",
     344             :                            magic_data.abi_extra,
     345             :                            module_magic_data->abi_extra)));
     346             :     }
     347             : 
     348             :     /*
     349             :      * Otherwise, spell out which fields don't agree.
     350             :      *
     351             :      * XXX this code has to be adjusted any time the set of fields in a magic
     352             :      * block change!
     353             :      */
     354           0 :     initStringInfo(&details);
     355             : 
     356           0 :     if (module_magic_data->funcmaxargs != magic_data.funcmaxargs)
     357             :     {
     358           0 :         if (details.len)
     359           0 :             appendStringInfoChar(&details, '\n');
     360           0 :         appendStringInfo(&details,
     361           0 :                          _("Server has FUNC_MAX_ARGS = %d, library has %d."),
     362             :                          magic_data.funcmaxargs,
     363             :                          module_magic_data->funcmaxargs);
     364             :     }
     365           0 :     if (module_magic_data->indexmaxkeys != magic_data.indexmaxkeys)
     366             :     {
     367           0 :         if (details.len)
     368           0 :             appendStringInfoChar(&details, '\n');
     369           0 :         appendStringInfo(&details,
     370           0 :                          _("Server has INDEX_MAX_KEYS = %d, library has %d."),
     371             :                          magic_data.indexmaxkeys,
     372             :                          module_magic_data->indexmaxkeys);
     373             :     }
     374           0 :     if (module_magic_data->namedatalen != magic_data.namedatalen)
     375             :     {
     376           0 :         if (details.len)
     377           0 :             appendStringInfoChar(&details, '\n');
     378           0 :         appendStringInfo(&details,
     379           0 :                          _("Server has NAMEDATALEN = %d, library has %d."),
     380             :                          magic_data.namedatalen,
     381             :                          module_magic_data->namedatalen);
     382             :     }
     383           0 :     if (module_magic_data->float8byval != magic_data.float8byval)
     384             :     {
     385           0 :         if (details.len)
     386           0 :             appendStringInfoChar(&details, '\n');
     387           0 :         appendStringInfo(&details,
     388           0 :                          _("Server has FLOAT8PASSBYVAL = %s, library has %s."),
     389           0 :                          magic_data.float8byval ? "true" : "false",
     390           0 :                          module_magic_data->float8byval ? "true" : "false");
     391             :     }
     392             : 
     393           0 :     if (details.len == 0)
     394           0 :         appendStringInfoString(&details,
     395           0 :                                _("Magic block has unexpected length or padding difference."));
     396             : 
     397           0 :     ereport(ERROR,
     398             :             (errmsg("incompatible library \"%s\": magic block mismatch",
     399             :                     libname),
     400             :              errdetail_internal("%s", details.data)));
     401             : }
     402             : 
     403             : 
     404             : /*
     405             :  * If name contains a slash, check if the file exists, if so return
     406             :  * the name.  Else (no slash) try to expand using search path (see
     407             :  * find_in_dynamic_libpath below); if that works, return the fully
     408             :  * expanded file name.  If the previous failed, append DLSUFFIX and
     409             :  * try again.  If all fails, just return the original name.
     410             :  *
     411             :  * The result will always be freshly palloc'd.
     412             :  */
     413             : static char *
     414       15596 : expand_dynamic_library_name(const char *name)
     415             : {
     416             :     bool        have_slash;
     417             :     char       *new;
     418             :     char       *full;
     419             : 
     420             :     Assert(name);
     421             : 
     422       15596 :     have_slash = (first_dir_separator(name) != NULL);
     423             : 
     424       15596 :     if (!have_slash)
     425             :     {
     426        4016 :         full = find_in_dynamic_libpath(name);
     427        4016 :         if (full)
     428           0 :             return full;
     429             :     }
     430             :     else
     431             :     {
     432       11580 :         full = substitute_libpath_macro(name);
     433       11580 :         if (pg_file_exists(full))
     434        1142 :             return full;
     435       10438 :         pfree(full);
     436             :     }
     437             : 
     438       14454 :     new = psprintf("%s%s", name, DLSUFFIX);
     439             : 
     440       14454 :     if (!have_slash)
     441             :     {
     442        4016 :         full = find_in_dynamic_libpath(new);
     443        4016 :         pfree(new);
     444        4016 :         if (full)
     445        4008 :             return full;
     446             :     }
     447             :     else
     448             :     {
     449       10438 :         full = substitute_libpath_macro(new);
     450       10438 :         pfree(new);
     451       10438 :         if (pg_file_exists(full))
     452       10438 :             return full;
     453           0 :         pfree(full);
     454             :     }
     455             : 
     456             :     /*
     457             :      * If we can't find the file, just return the string as-is. The ensuing
     458             :      * load attempt will fail and report a suitable message.
     459             :      */
     460           8 :     return pstrdup(name);
     461             : }
     462             : 
     463             : /*
     464             :  * Check a restricted library name.  It must begin with "$libdir/plugins/"
     465             :  * and there must not be any directory separators after that (this is
     466             :  * sufficient to prevent ".." style attacks).
     467             :  */
     468             : static void
     469           0 : check_restricted_library_name(const char *name)
     470             : {
     471           0 :     if (strncmp(name, "$libdir/plugins/", 16) != 0 ||
     472           0 :         first_dir_separator(name + 16) != NULL)
     473           0 :         ereport(ERROR,
     474             :                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
     475             :                  errmsg("access to library \"%s\" is not allowed",
     476             :                         name)));
     477           0 : }
     478             : 
     479             : /*
     480             :  * Substitute for any macros appearing in the given string.
     481             :  * Result is always freshly palloc'd.
     482             :  */
     483             : static char *
     484       30050 : substitute_libpath_macro(const char *name)
     485             : {
     486             :     const char *sep_ptr;
     487             : 
     488             :     Assert(name != NULL);
     489             : 
     490             :     /* Currently, we only recognize $libdir at the start of the string */
     491       30050 :     if (name[0] != '$')
     492        1142 :         return pstrdup(name);
     493             : 
     494       28908 :     if ((sep_ptr = first_dir_separator(name)) == NULL)
     495        8032 :         sep_ptr = name + strlen(name);
     496             : 
     497       28908 :     if (strlen("$libdir") != sep_ptr - name ||
     498       28908 :         strncmp(name, "$libdir", strlen("$libdir")) != 0)
     499           0 :         ereport(ERROR,
     500             :                 (errcode(ERRCODE_INVALID_NAME),
     501             :                  errmsg("invalid macro name in dynamic library path: %s",
     502             :                         name)));
     503             : 
     504       28908 :     return psprintf("%s%s", pkglib_path, sep_ptr);
     505             : }
     506             : 
     507             : 
     508             : /*
     509             :  * Search for a file called 'basename' in the colon-separated search
     510             :  * path Dynamic_library_path.  If the file is found, the full file name
     511             :  * is returned in freshly palloc'd memory.  If the file is not found,
     512             :  * return NULL.
     513             :  */
     514             : static char *
     515        8032 : find_in_dynamic_libpath(const char *basename)
     516             : {
     517             :     const char *p;
     518             :     size_t      baselen;
     519             : 
     520             :     Assert(basename != NULL);
     521             :     Assert(first_dir_separator(basename) == NULL);
     522             :     Assert(Dynamic_library_path != NULL);
     523             : 
     524        8032 :     p = Dynamic_library_path;
     525        8032 :     if (strlen(p) == 0)
     526           0 :         return NULL;
     527             : 
     528        8032 :     baselen = strlen(basename);
     529             : 
     530             :     for (;;)
     531           0 :     {
     532             :         size_t      len;
     533             :         char       *piece;
     534             :         char       *mangled;
     535             :         char       *full;
     536             : 
     537        8032 :         piece = first_path_var_separator(p);
     538        8032 :         if (piece == p)
     539           0 :             ereport(ERROR,
     540             :                     (errcode(ERRCODE_INVALID_NAME),
     541             :                      errmsg("zero-length component in parameter dynamic_library_path")));
     542             : 
     543        8032 :         if (piece == NULL)
     544        8032 :             len = strlen(p);
     545             :         else
     546           0 :             len = piece - p;
     547             : 
     548        8032 :         piece = palloc(len + 1);
     549        8032 :         strlcpy(piece, p, len + 1);
     550             : 
     551        8032 :         mangled = substitute_libpath_macro(piece);
     552        8032 :         pfree(piece);
     553             : 
     554        8032 :         canonicalize_path(mangled);
     555             : 
     556             :         /* only absolute paths */
     557        8032 :         if (!is_absolute_path(mangled))
     558           0 :             ereport(ERROR,
     559             :                     (errcode(ERRCODE_INVALID_NAME),
     560             :                      errmsg("component in parameter dynamic_library_path is not an absolute path")));
     561             : 
     562        8032 :         full = palloc(strlen(mangled) + 1 + baselen + 1);
     563        8032 :         sprintf(full, "%s/%s", mangled, basename);
     564        8032 :         pfree(mangled);
     565             : 
     566        8032 :         elog(DEBUG3, "find_in_dynamic_libpath: trying \"%s\"", full);
     567             : 
     568        8032 :         if (pg_file_exists(full))
     569        4008 :             return full;
     570             : 
     571        4024 :         pfree(full);
     572             : 
     573        4024 :         if (p[len] == '\0')
     574        4024 :             break;
     575             :         else
     576           0 :             p += len + 1;
     577             :     }
     578             : 
     579        4024 :     return NULL;
     580             : }
     581             : 
     582             : 
     583             : /*
     584             :  * Find (or create) a rendezvous variable that one dynamically
     585             :  * loaded library can use to meet up with another.
     586             :  *
     587             :  * On the first call of this function for a particular varName,
     588             :  * a "rendezvous variable" is created with the given name.
     589             :  * The value of the variable is a void pointer (initially set to NULL).
     590             :  * Subsequent calls with the same varName just return the address of
     591             :  * the existing variable.  Once created, a rendezvous variable lasts
     592             :  * for the life of the process.
     593             :  *
     594             :  * Dynamically loaded libraries can use rendezvous variables
     595             :  * to find each other and share information: they just need to agree
     596             :  * on the variable name and the data it will point to.
     597             :  */
     598             : void      **
     599        3412 : find_rendezvous_variable(const char *varName)
     600             : {
     601             :     static HTAB *rendezvousHash = NULL;
     602             : 
     603             :     rendezvousHashEntry *hentry;
     604             :     bool        found;
     605             : 
     606             :     /* Create a hashtable if we haven't already done so in this process */
     607        3412 :     if (rendezvousHash == NULL)
     608             :     {
     609             :         HASHCTL     ctl;
     610             : 
     611        3406 :         ctl.keysize = NAMEDATALEN;
     612        3406 :         ctl.entrysize = sizeof(rendezvousHashEntry);
     613        3406 :         rendezvousHash = hash_create("Rendezvous variable hash",
     614             :                                      16,
     615             :                                      &ctl,
     616             :                                      HASH_ELEM | HASH_STRINGS);
     617             :     }
     618             : 
     619             :     /* Find or create the hashtable entry for this varName */
     620        3412 :     hentry = (rendezvousHashEntry *) hash_search(rendezvousHash,
     621             :                                                  varName,
     622             :                                                  HASH_ENTER,
     623             :                                                  &found);
     624             : 
     625             :     /* Initialize to NULL if first time */
     626        3412 :     if (!found)
     627        3412 :         hentry->varValue = NULL;
     628             : 
     629        3412 :     return &hentry->varValue;
     630             : }
     631             : 
     632             : /*
     633             :  * Estimate the amount of space needed to serialize the list of libraries
     634             :  * we have loaded.
     635             :  */
     636             : Size
     637         828 : EstimateLibraryStateSpace(void)
     638             : {
     639             :     DynamicFileList *file_scanner;
     640         828 :     Size        size = 1;
     641             : 
     642        2070 :     for (file_scanner = file_list;
     643             :          file_scanner != NULL;
     644        1242 :          file_scanner = file_scanner->next)
     645        1242 :         size = add_size(size, strlen(file_scanner->filename) + 1);
     646             : 
     647         828 :     return size;
     648             : }
     649             : 
     650             : /*
     651             :  * Serialize the list of libraries we have loaded to a chunk of memory.
     652             :  */
     653             : void
     654         828 : SerializeLibraryState(Size maxsize, char *start_address)
     655             : {
     656             :     DynamicFileList *file_scanner;
     657             : 
     658        2070 :     for (file_scanner = file_list;
     659             :          file_scanner != NULL;
     660        1242 :          file_scanner = file_scanner->next)
     661             :     {
     662             :         Size        len;
     663             : 
     664        1242 :         len = strlcpy(start_address, file_scanner->filename, maxsize) + 1;
     665             :         Assert(len < maxsize);
     666        1242 :         maxsize -= len;
     667        1242 :         start_address += len;
     668             :     }
     669         828 :     start_address[0] = '\0';
     670         828 : }
     671             : 
     672             : /*
     673             :  * Load every library the serializing backend had loaded.
     674             :  */
     675             : void
     676        2640 : RestoreLibraryState(char *start_address)
     677             : {
     678        7438 :     while (*start_address != '\0')
     679             :     {
     680        4798 :         internal_load_library(start_address);
     681        4798 :         start_address += strlen(start_address) + 1;
     682             :     }
     683        2640 : }

Generated by: LCOV version 1.14